#!/usr/bin/perl
#line 16


####
#### All Code by Steve Michel
####


use Math::Complex;
use Math::Trig;

# define degree to radians 
$rad= 3.14159265358979323846/180;
$pi = 3.14159265358979323846;


$StartOld = "temp";
#$DestOld = "temp";
$DestOld = "0,0;";

$dxfFile1 = $ARGV[0];
$dxfFile2 = $ARGV[1];
$dxfFile3 = $ARGV[2];



print ("file A = " . $dxfFile1  . "\n" );
print ("file B = " . $dxfFile2  . "\n" );
print ("file C = " . $dxfFile3  . "\n" );

print ( "\n" );
print ( "\n" );

###################################################################################
###################################################################################
#########                                                                   #######
######### open $dxfFile1										            #######
#########                                                                   #######
###################################################################################
###################################################################################




print ("opening file... " . $dxfFile1 . "\n" );

open (FILEHANDLE, $dxfFile1);
while (<FILEHANDLE>)  { push(@lines,$_) }



$listNum = @lines;

for ($Loop = 0; $Loop <= $listNum; $Loop++){
	chomp ($lines[$Loop]);
	}

$counter=0;

for ($Loop = 0; $Loop <= $listNum; $Loop++){

	$TEMP = $lines[$Loop];

	if ($TEMP eq "LINE"){
		$counter=$counter+1;
		$RibOneXs= $lines[$Loop + 6]/.025400 ;
		$RibOneYs = $lines[$Loop + 8]/.025400 ;
		$RibOneZs = $lines[$Loop + 10]/.025400 ;

		$RibOneXs[$counter] = int($RibOneXs*10000);
		$RibOneYs[$counter] = int($RibOneYs*10000);
		$RibOneZs[$counter] = int($RibOneZs*-10000);
		
		$RibOneXs[$counter] = $RibOneXs[$counter]/10000;
		$RibOneYs[$counter] = $RibOneYs[$counter]/10000;
		$RibOneZs[$counter] = $RibOneZs[$counter]/10000;
		

		$RibOneXd = $lines[$Loop + 12]/.025400 ;
		$RibOneYd = $lines[$Loop + 14]/.025400 ;
		$RibOneZd = $lines[$Loop + 16]/.025400 ;

		$RibOneXs[$counter+1] = int($RibOneXd*10000);
		$RibOneYs[$counter+1] = int($RibOneYd*10000);
		$RibOneZs[$counter+1] = int($RibOneZd*-10000);
		
		$RibOneXs[$counter+1] = $RibOneXs[$counter+1]/10000;
		$RibOneYs[$counter+1] = $RibOneYs[$counter+1]/10000;
		$RibOneZs[$counter+1] = $RibOneZs[$counter+1]/10000;


			}
		}

		
		$total1 = $counter +1 ;
print ($total1 . "\n");

for ($Loop = 1; $Loop <= $total1; $Loop++){
	
	print ($Loop . "    ");
#	$thing=$Loop;
	print ( $RibOneXs[$Loop] . "," . $RibOneYs[$Loop] . "," . $RibOneZs[$Loop] . "\n" );
	
}
	
###################################################################################
###################################################################################
#########                                                                   #######
######### open $dxfFile2										            #######
#########                                                                   #######
###################################################################################
###################################################################################

print ("opening file... " . $dxfFile2 . "\n" );

open (FILEHANDLE2, $dxfFile2);
while (<FILEHANDLE2>)  { push(@lines2,$_) }



$listNum2 = @lines2;

for ($Loop = 0; $Loop <= $listNum2; $Loop++){
	chomp ($lines2[$Loop]);
	}

$counter=0;

for ($Loop = 0; $Loop <= $listNum2; $Loop++){

	$TEMP = $lines2[$Loop];

	if ($TEMP eq "LINE"){
		$counter=$counter+1;
		$RibTwoXs= $lines2[$Loop + 6]/.025400 ;
		$RibTwoYs = $lines2[$Loop + 8]/.025400 ;
		$RibTwoZs = $lines2[$Loop + 10]/.025400 ;

		$RibTwoXs[$counter] = int($RibTwoXs*10000);
		$RibTwoYs[$counter] = int($RibTwoYs*10000);
		$RibTwoZs[$counter] = int($RibTwoZs*-10000);
		
		$RibTwoXs[$counter] = $RibTwoXs[$counter]/10000;
		$RibTwoYs[$counter] = $RibTwoYs[$counter]/10000;
		$RibTwoZs[$counter] = $RibTwoZs[$counter]/10000;
		

		$RibTwoXd = $lines2[$Loop + 12]/.025400 ;
		$RibTwoYd = $lines2[$Loop + 14]/.025400 ;
		$RibTwoZd = $lines2[$Loop + 16]/.025400 ;

		$RibTwoXs[$counter+1] = int($RibTwoXd*10000);
		$RibTwoYs[$counter+1] = int($RibTwoYd*10000);
		$RibTwoZs[$counter+1] = int($RibTwoZd*-10000);
		
		$RibTwoXs[$counter+1] = $RibTwoXs[$counter+1]/10000;
		$RibTwoYs[$counter+1] = $RibTwoYs[$counter+1]/10000;
		$RibTwoZs[$counter+1] = $RibTwoZs[$counter+1]/10000;

			}
		}

		
		$total2 = $counter +1 ;
print ($total2 . "\n");

for ($Loop = 1; $Loop <= $total2; $Loop++){
	
	print ($Loop . "    ");
#	$thing=$Loop;

	print ( $RibTwoXs[$Loop] . "," . $RibTwoYs[$Loop] . "," . $RibTwoZs[$Loop] . "\n" );
	
}
	

###################################################################################
###################################################################################
#########                                                                   #######
######### open $dxfFile3										            #######
#########                                                                   #######
###################################################################################
###################################################################################

print ("opening file... " . $dxfFile3 . "\n" );

open (FILEHANDLE3, $dxfFile3);
while (<FILEHANDLE3>)  { push(@lines3,$_) }



$listNum3 = @lines3;

for ($Loop = 0; $Loop <= $listNum3; $Loop++){
	chomp ($lines3[$Loop]);
	}

$counter=0;

for ($Loop = 0; $Loop <= $listNum3; $Loop++){

	$TEMP = $lines3[$Loop];

	if ($TEMP eq "LINE"){
		$counter=$counter+1;
		$RibTreXs= $lines3[$Loop + 6]/.025400 ;
		$RibTreYs = $lines3[$Loop + 8]/.025400 ;
		$RibTreZs = $lines3[$Loop + 10]/.025400 ;

		$RibTreXs[$counter] = int($RibTreXs*10000);
		$RibTreYs[$counter] = int($RibTreYs*10000);
		$RibTreZs[$counter] = int($RibTreZs*-10000);
		
		$RibTreXs[$counter] = $RibTreXs[$counter]/10000;
		$RibTreYs[$counter] = $RibTreYs[$counter]/10000;
		$RibTreZs[$counter] = $RibTreZs[$counter]/10000;
		

		$RibTreXd = $lines3[$Loop + 12]/.025400 ;
		$RibTreYd = $lines3[$Loop + 14]/.025400 ;
		$RibTreZd = $lines3[$Loop + 16]/.025400 ;

		$RibTreXs[$counter+1] = int($RibTreXd*10000);
		$RibTreYs[$counter+1] = int($RibTreYd*10000);
		$RibTreZs[$counter+1] = int($RibTreZd*-10000);
		
		$RibTreXs[$counter+1] = $RibTreXs[$counter+1]/10000;
		$RibTreYs[$counter+1] = $RibTreYs[$counter+1]/10000;
		$RibTreZs[$counter+1] = $RibTreZs[$counter+1]/10000;

			}
		}

		
		$total3 = $counter +1 ;
print ($total3 . "\n");

for ($Loop = 1; $Loop <= $total3; $Loop++){
	
	print ($Loop . "    ");
#	$thing=$Loop;

	print ( $RibTreXs[$Loop] . "," . $RibTreYs[$Loop] . "," . $RibTreZs[$Loop] . "\n" );
	
}


for ($Loop = 1; $Loop <= $total1; $Loop++){
	$HoldDotRibOne[$Loop] = 0;
}
	
for ($Loop = 1; $Loop <= $total2; $Loop++){
	$HoldDotRibTwo[$Loop] = 0;
	
}

for ($Loop = 1; $Loop <= $total3; $Loop++){
	$HoldDotRibTre[$Loop] = 0;	
	
}




print ( "\n" );


###################################################################################
###################################################################################
#########                                                                   #######
######### The following will try to flatten a curved surface	            #######
######### onto the XY plane with all points resting on Z=zero	            #######
#########                                                                   #######
###################################################################################
###################################################################################

#####  Step #1 move 1st point of rib one to 0,0,0 and translate all points accordingly

for ($NewCounter=1; $NewCounter < $total1; $NewCounter++){


	if ($NewCounter==1){
	
for ($Loop = 1; $Loop <= $total1; $Loop++){

		$TempRibOneXs[$Loop] = $RibOneXs[$Loop] - $RibOneXs[$NewCounter];
		$TempRibOneYs[$Loop] = $RibOneYs[$Loop] - $RibOneYs[$NewCounter];
		$TempRibOneZs[$Loop] = $RibOneZs[$Loop] - $RibOneZs[$NewCounter];
	}

	for ($Loop = 1; $Loop <= $total1; $Loop++){
		$NewRibOneXs[$Loop] = sprintf("%.6f", $TempRibOneXs[$Loop]);
		$NewRibOneYs[$Loop] = sprintf("%.6f", $TempRibOneYs[$Loop]);
		$NewRibOneZs[$Loop] = sprintf("%.6f", $TempRibOneZs[$Loop]);
	}
###############################2
		
for ($Loop = 1; $Loop <= $total2; $Loop++){
		$TempRibTwoXs[$Loop] = $RibTwoXs[$Loop] - $RibOneXs[$NewCounter];
		$TempRibTwoYs[$Loop] = $RibTwoYs[$Loop] - $RibOneYs[$NewCounter];
		$TempRibTwoZs[$Loop] = $RibTwoZs[$Loop] - $RibOneZs[$NewCounter];
	}

	for ($Loop = 1; $Loop <= $total2; $Loop++){
		$NewRibTwoXs[$Loop] = sprintf("%.6f", $TempRibTwoXs[$Loop]);
		$NewRibTwoYs[$Loop] = sprintf("%.6f", $TempRibTwoYs[$Loop]);
		$NewRibTwoZs[$Loop] = sprintf("%.6f", $TempRibTwoZs[$Loop]);
	}

###############################3
	
for ($Loop = 1; $Loop <= $total3; $Loop++){
#	print ($Loop . "  " . $RibOneXs[1] . "         " . "\n");
		$TempRibTreXs[$Loop] = $RibTreXs[$Loop] - $RibOneXs[$NewCounter];
		$TempRibTreYs[$Loop] = $RibTreYs[$Loop] - $RibOneYs[$NewCounter];
		$TempRibTreZs[$Loop] = $RibTreZs[$Loop] - $RibOneZs[$NewCounter];
	}

	for ($Loop = 1; $Loop <= $total3; $Loop++){
		$NewRibTreXs[$Loop] = sprintf("%.6f", $TempRibTreXs[$Loop]);
		$NewRibTreYs[$Loop] = sprintf("%.6f", $TempRibTreYs[$Loop]);
		$NewRibTreZs[$Loop] = sprintf("%.6f", $TempRibTreZs[$Loop]);
	}
###############################print	
}

print "Point locations after translation ";
print $NewCounter;
print ( "\n" );
print "Rib 1";
print ( "\n" );

for ($Loop = 1; $Loop <= $total1; $Loop++){
	print $Loop;
	print "  ";
	print ( $NewRibOneXs[$Loop] . "," . $NewRibOneYs[$Loop] . "," . $NewRibOneZs[$Loop] . "\n" );	
}

print ( "\n" );
print "Rib 2";
print ( "\n" );

for ($Loop = 1; $Loop <= $total2; $Loop++){
	print $Loop;
	print "  ";
	print ( $NewRibTwoXs[$Loop] . "," . $NewRibTwoYs[$Loop] . "," . $NewRibTwoZs[$Loop] . "\n" );
}
print ( "\n" );
print ( "\n" );
print "Rib 3";
print ( "\n" );
for ($Loop = 1; $Loop <= $total3; $Loop++){
	print $Loop;
	print "  ";
	print ( $NewRibTreXs[$Loop] . "," . $NewRibTreYs[$Loop] . "," . $NewRibTreZs[$Loop] . "\n" );
}

print ( "\n" );

###################################################
###  Step 2
###  Locate position of 1st point of rib two, 
###  then rotate all point around 0,0,0
###  until 1st point of rib two is X0 and Z0
###
print $NewCounter;
print "    ";
print ( $NewRibTwoXs[$NewCounter] . "," . $NewRibTwoYs[$NewCounter] . "," . $NewRibTwoZs[$NewCounter] . "\n" );

#####
##### establish X rotation

$ExFix = tan($NewRibTwoZs[$NewCounter]/$NewRibTwoYs[$NewCounter]);
$ExFix = sprintf("%.6f", $ExFix);
$ExFixDeg = ($ExFix*180)/$pi; 
$ExFixDeg = sprintf("%.6f", $ExFixDeg);

print $ExFixDeg;
print "      estimated X axis correction angle rotation  ";
print $NewCounter;
print ( "\n" );
##### establish Z rotation

$ZeeFix = tan($NewRibTwoXs[$NewCounter]/$NewRibTwoYs[$NewCounter]);
$ZeeFix = sprintf("%.6f", $ZeeFix);
$ZeeFixDeg = ($ZeeFix*180)/$pi; 
$ZeeFixDeg = sprintf("%.6f", $ZeeFixDeg);
print $ZeeFixDeg;
print "      estimated Z axis correction angle rotation  ";
print $NewCounter;

## Determine ExFix compensation value

$MaxExFixVal = 1.03;
$MinExFixVal = .95;
$WinExFixVal = .95;
$UseExFixVal = .95;
$SetExFixVal = 5;

	for ($ThisLoop = $MinExFixVal; $ThisLoop <= $MaxExFixVal; $ThisLoop = $ThisLoop + .0001) {
		
	$xr = $ExFix * $ThisLoop * -1;
	$Loop = $NewCounter;
	
		$xa = $NewRibTwoXs[$Loop];
		$ya = $NewRibTwoYs[$Loop];
		$za = $NewRibTwoZs[$Loop];
		
		
		$xb = $xa;       
		$yb = $ya*cos($xr)-$za*sin($xr);
		$zb = $ya*sin($xr)+$za*cos($xr);
		
		$NewestRibTwoXs[$Loop] = sprintf("%.6f",$xb);
		$NewestRibTwoYs[$Loop] = sprintf("%.6f",$yb);			
		$NewestRibTwoZs[$Loop] = sprintf("%.6f",$zb);
		
		if 	(abs($NewestRibTwoZs[$Loop]) < abs($SetExFixVal)) {
			$SetExFixVal = $NewestRibTwoZs[$Loop];
			$WinExFixVal = $ThisLoop;
				}
			
#		print ( $NewestRibTwoXs[$Loop] . "," . $NewestRibTwoYs[$Loop] . "," . $NewestRibTwoZs[$Loop] . "     " . $SetExFixVal . "\n" );	
		}
		

print ( "\n" );
print ( "\n" );

####
#### Rotate All points X axis first
#####			$xb= $xa;       
#####			$yb= $ya*cos($xr*$rad)-$za*sin($xr*$rad);
#####			$zb= $ya*sin($xr*$rad)+$za*cos($xr*$rad);

$ExFix = $ExFix * $WinExFixVal;

$xr = $ExFix * -1;
print ("values after X rotation   " . $NewCounter . "\n" );
print ("rib 1 \n");

###########Rib1
	for ($Loop = 1; $Loop <= $total1; $Loop++){
		$xa = $NewRibOneXs[$Loop];
		$ya = $NewRibOneYs[$Loop];
		$za = $NewRibOneZs[$Loop];
		
		
		$xb = $xa;       
		$yb = $ya*cos($xr)-$za*sin($xr);
		$zb = $ya*sin($xr)+$za*cos($xr);
		
		$NewestRibOneXs[$Loop] = sprintf("%.6f",$xb);
		$NewestRibOneYs[$Loop] = sprintf("%.6f",$yb);		
		$NewestRibOneZs[$Loop] = sprintf("%.6f",$zb);
			
		print $Loop;
		print "  ";
		print ( $NewestRibOneXs[$Loop] . "," . $NewestRibOneYs[$Loop] . "," . $NewestRibOneZs[$Loop] . "\n" );	
	}	
print ( "\n" );
print ( "\n" );	
###########Rib2
print "rib 2 \n";
	for ($Loop = 1; $Loop <= $total2; $Loop++){
		$xa = $NewRibTwoXs[$Loop];
		$ya = $NewRibTwoYs[$Loop];
		$za = $NewRibTwoZs[$Loop];
		
		
		$xb = $xa;       
		$yb = $ya*cos($xr)-$za*sin($xr);
		$zb = $ya*sin($xr)+$za*cos($xr);
		
		$NewestRibTwoXs[$Loop] = sprintf("%.6f",$xb);
		$NewestRibTwoYs[$Loop] = sprintf("%.6f",$yb);			
		$NewestRibTwoZs[$Loop] = sprintf("%.6f",$zb);
	
		print $Loop;
		print "  ";
			
		print ( $NewestRibTwoXs[$Loop] . "," . $NewestRibTwoYs[$Loop] . "," . $NewestRibTwoZs[$Loop] . "\n" );	
	}	
print ( "\n" );
print ( "\n" );
###########Rib3
print "rib 3 \n";
	for ($Loop = 1; $Loop <= $total3; $Loop++){
		$xa = $NewRibTreXs[$Loop];
		$ya = $NewRibTreYs[$Loop];
		$za = $NewRibTreZs[$Loop];
		
		
		$xb = $xa;       
		$yb = $ya*cos($xr)-$za*sin($xr);
		$zb = $ya*sin($xr)+$za*cos($xr);
		
		$NewestRibTreXs[$Loop] = sprintf("%.6f",$xb);
		$NewestRibTreYs[$Loop] = sprintf("%.6f",$yb);			
		$NewestRibTreZs[$Loop] = sprintf("%.6f",$zb);
		
		print $Loop;
		print "  ";			
		print ( $NewestRibTreXs[$Loop] . "," . $NewestRibTreYs[$Loop] . "," . $NewestRibTreZs[$Loop] . "\n" );	
	}	
print ( "\n" );
print ( "\n" );	
####
#### Rotate All points Z axis Next
#####			$xb= $xa;       
#####			$yb= $ya*cos($xr*$rad)-$za*sin($xr*$rad);
#####			$zb= $ya*sin($xr*$rad)+$za*cos($xr*$rad);



## Determine ZeeFix compensation value

$MaxZeeFixVal = 1.03;
$MinZeeFixVal = .95;
$WinZeeFixVal = .95;
$UseZeeFixVal = .95;
$SetZeeFixVal = 5;

	for ($ThisLoop = $MinZeeFixVal; $ThisLoop <= $MaxZeeFixVal; $ThisLoop = $ThisLoop + .0001) {
		
	$zr = $ZeeFix * $ThisLoop;
	$Loop = $NewCounter;
			

		$xc = $NewestRibTwoXs[$Loop];
		$yc = $NewestRibTwoYs[$Loop];
		$zc = $NewestRibTwoZs[$Loop];
		
			$xd = $xc*cos($zr)-$yc*sin($zr);
			$yd = $xc*sin($zr)+$yc*cos($zr);
			$zd = $zc;
		
		$NewNewRibTwoXs[$Loop] = sprintf("%.6f",$xd);
		$NewNewRibTwoYs[$Loop] = sprintf("%.6f",$yd);			
		$NewNewRibTwoZs[$Loop] = sprintf("%.6f",$zd);
			
		
		if 	(abs($NewNewRibTwoXs[$Loop]) < abs($SetZeeFixVal)) {
			$SetZeeFixVal = $NewNewRibTwoXs[$Loop];
			$WinZeeFixVal = $ThisLoop;
				}
			
#		print ( $NewNewRibTwoXs[$Loop] . "," . $NewNewRibTwoYs[$Loop] . "," . $NewNewRibTwoZs[$Loop] . "     " . $SetZeeFixVal . "\n" );	
		}
		
#		print $WinZeeFixVal;
#print ( "\n" );
#print ( "\n" );

#$zr = $ZeeFixDeg;
$zr = $ZeeFix * $WinZeeFixVal;

$pxr = $ExFixDeg * $WinExFixVal;
$pzr = $ZeeFixDeg * $WinZeeFixVal;

print $pxr;
print "    corrected X rotation angle  ";
print $NewCounter;
print ( "\n" );
print $pzr;
print "    corrected Z rotation angle  ";
print $NewCounter;
print ( "\n" );
print ( "\n" );
###########Rib1
print "values after Z rotation  ";
print $NewCounter;
print ( "\n" );
print "rib 1 \n";

$NewXtest = 1;
$NewZtest = 1;
$NewValTest = 0;


	for ($Loop = 1; $Loop <= $total1; $Loop++){
		$xc = $NewestRibOneXs[$Loop];
		$yc = $NewestRibOneYs[$Loop];
		$zc = $NewestRibOneZs[$Loop];
		
			$xd = $xc*cos($zr)-$yc*sin($zr);
			$yd = $xc*sin($zr)+$yc*cos($zr);
			$zd = $zc;
		
		$NewNewRibOneXs[$Loop] = sprintf("%.6f",$xd);
		$NewNewRibOneYs[$Loop] = sprintf("%.6f",$yd);			
		$NewNewRibOneZs[$Loop] = sprintf("%.6f",$zd);
	
		$ZeroVal = 0;
			
		if (abs($NewNewRibOneXs[$Loop]) < abs(.0001)){$NewNewRibOneXs[$Loop] = sprintf("%.6f",$ZeroVal);}
		if (abs($NewNewRibOneZs[$Loop]) < abs(.0001)){$NewNewRibOneZs[$Loop] = sprintf("%.6f",$ZeroVal);}
		
		if ($NewNewRibOneXs[$Loop] == 0) {$NewXtest = 5;}
		if ($NewNewRibOneZs[$Loop] == 0) {$NewZtest = 5;}
		$NewValTestRibOne[$Loop] = $NewXtest * $NewZtest;

		print ( $NewNewRibOneXs[$Loop] . "," . $NewNewRibOneYs[$Loop] . "," . $NewNewRibOneZs[$Loop] . "         "  . $NewValTestRibOne[$Loop] . "\n" );					

$NewXtest = 1;
$NewZtest = 1;
$NewValTest = 0;
		}
			
print ( "\n" );
print ( "\n" );
###########Rib2
$NewXtest = 1;
$NewZtest = 1;
$NewValTest = 0;

print "rib 2 \n";
	for ($Loop = 1; $Loop <= $total2; $Loop++){
		$xc = $NewestRibTwoXs[$Loop];
		$yc = $NewestRibTwoYs[$Loop];
		$zc = $NewestRibTwoZs[$Loop];
		
			$xd = $xc*cos($zr)-$yc*sin($zr);
			$yd = $xc*sin($zr)+$yc*cos($zr);
			$zd = $zc;
		
		$NewNewRibTwoXs[$Loop] = sprintf("%.6f",$xd);
		$NewNewRibTwoYs[$Loop] = sprintf("%.6f",$yd);			
		$NewNewRibTwoZs[$Loop] = sprintf("%.6f",$zd);

		if (abs($NewNewRibTwoXs[$Loop]) < abs(.0001)){$NewNewRibTwoXs[$Loop] = sprintf("%.6f",$ZeroVal);}
		if (abs($NewNewRibTwoZs[$Loop]) < abs(.0001)){$NewNewRibTwoZs[$Loop] = sprintf("%.6f",$ZeroVal);}
		
		if ($NewNewRibTwoXs[$Loop] == 0) {$NewXtest = 5;}
		if ($NewNewRibTwoZs[$Loop] == 0) {$NewZtest = 5;}
		$NewValTestRibTwo[$Loop] = $NewXtest * $NewZtest;
		
		
		print ( $NewNewRibTwoXs[$Loop] . "," . $NewNewRibTwoYs[$Loop] . "," . $NewNewRibTwoZs[$Loop] .  "         "  . $NewValTestRibTwo[$Loop] . "\n" );					
	
$NewXtest = 1;
$NewZtest = 1;
$NewValTest = 0;
			
			}
print ( "\n" );
print ( "\n" );
###########Rib3

$NewXtest = 1;
$NewZtest = 1;
$NewValTest = 0;
print "rib 3 \n";

	for ($Loop = 1; $Loop <= $total3; $Loop++){
		$xc = $NewestRibTreXs[$Loop];
		$yc = $NewestRibTreYs[$Loop];
		$zc = $NewestRibTreZs[$Loop];
		
			$xd = $xc*cos($zr)-$yc*sin($zr);
			$yd = $xc*sin($zr)+$yc*cos($zr);
			$zd = $zc;
		
		$NewNewRibTreXs[$Loop] = sprintf("%.6f",$xd);;
		$NewNewRibTreYs[$Loop] = sprintf("%.6f",$yd);			
		$NewNewRibTreZs[$Loop] = sprintf("%.6f",$zd);
		
		if (abs($NewNewRibTreXs[$Loop]) < abs(.0001)){$NewNewRibTreXs[$Loop] = sprintf("%.6f",$ZeroVal);}
		if (abs($NewNewRibTreZs[$Loop]) < abs(.0001)){$NewNewRibTreZs[$Loop] = sprintf("%.6f",$ZeroVal);}		

		if ($NewNewRibTreXs[$Loop] == 0) {$NewXtest = 5;}
		if ($NewNewRibTreZs[$Loop] == 0) {$NewZtest = 5;}
		$NewValTestRibTre[$Loop] = $NewXtest * $NewZtest;
		
			print ( $NewNewRibTreXs[$Loop] . "," . $NewNewRibTreYs[$Loop] . "," . $NewNewRibTreZs[$Loop] . "         "  . $NewValTestRibTre[$Loop] . "\n" );
			
$NewXtest = 1;
$NewZtest = 1;
$NewValTest = 0;
			
							
	}


##############
#### Determine which points to rotate on Y axis
####
#### Logic: already at X=0 + Z=0 no need for further Y rot
##############

##############
#### Determine  Y rotation value
##############



$NextNextNext = $NewCounter +1;

print ( "\n" );
print $NewNewRibOneZs[$NextNextNext];
print " / ";
print $NewNewRibOneXs[$NextNextNext];
print ( "\n" );
print ( "\n" );

$WyFix = tan($NewNewRibOneZs[$NextNextNext]/$NewNewRibOneXs[$NextNextNext]);
$WyFix = sprintf("%.6f", $WyFix);
$WyFixDeg = ($WyFix*180)/$pi; 
$WyFixDeg = sprintf("%.6f", $WyFixDeg);

print $WyFixDeg;
print "      estimated Y axis correction angle   ";
print $NewCounter;
print ( "\n" );
print ( "\n" );

## Determine WyFix compensation value

$MaxWyFixVal = 1.03;
$MinWyFixVal = .95;
$WinWyFixVal = .95;
$UseWyFixVal = .95;
$SetWyFixVal = 5;

	for ($ThisLoop = $MinZeeFixVal; $ThisLoop <= $MaxZeeFixVal; $ThisLoop = $ThisLoop + .0001) {
		
	$yr = $WyFix * $ThisLoop;
	$Loop = $NewCounter +1;
			

		$xb = $NewNewRibOneXs[$Loop];
		$yb = $NewNewRibOneYs[$Loop];
		$zb = $NewNewRibOneZs[$Loop];
		
			$xc = $zb*sin($yr)+$xb*cos($yr);
			$yc = $yb;
			$zc = $zb*cos($yr)-$xb*sin($yr);
		
		$YrotRibOneXs[$Loop] = sprintf("%.6f",$xc);
		$YrotRibOneYs[$Loop] = sprintf("%.6f",$yc);			
		$YrotRibOneZs[$Loop] = sprintf("%.6f",$zc);
			
		
		if 	(abs($YrotRibOneZs[$Loop]) < abs($SetWyFixVal)) {
			$SetWyFixVal = $YrotRibOneZs[$Loop];
			$WinWyFixVal = $ThisLoop;
				}
			
#		print ( $YrotRibOneXs[$Loop] . "," . $YrotRibOneYs[$Loop] . "," . $YrotRibOneZs[$Loop] . "     " . $SetWyFixVal . "\n" );	
		}
	
$yr = $WyFix * $WinWyFixVal;
$pyr = $WyFixDeg * $WinWyFixVal;		
		
			
		print $WinWyFixVal;
print ( "\n" );
	print $pyr;
	print "   corrected Y axis rotation value   ";
	print $NewCounter;
print ( "\n" );

$yr = $WyFix * $WinWyFixVal;

$pyr = $WyFixDeg * $WinWyFixVal;

##############
#### Rotate eligible points on Y
##############
###########Rib1

print ( "\n" );
for ($Loop = 1; $Loop <= $total1; $Loop++){
#	print $HoldDotRibOne[$Loop];
#	print ( "\n" );
}
print ( "\n" );

print "values after Y rotation   ";
print $NewCounter;
print ( "\n" );
print "rib 1 \n";

$NewXtest = 1;
$NewZtest = 1;
$NewestValTest = 0;

$decra = $NewCounter -1;




#################Rib one
	for ($Loop = 1; $Loop <= $total1; $Loop++){
		
		$gSpot1 = $HoldDotRibOne[$Loop];	

		
		$xLastPass = $NewNewRibOneXs[$Loop];
		$yLastPass = $NewNewRibOneYs[$Loop];
		$zLastPass = $NewNewRibOneZs[$Loop];

		
		$xb = $NewNewRibOneXs[$Loop];
		$yb = $NewNewRibOneYs[$Loop];
		$zb = $NewNewRibOneZs[$Loop];
		
			$xc = $zb*sin($yr)+$xb*cos($yr);
			$yc = $yb;
			$zc = $zb*cos($yr)-$xb*sin($yr);
			
		if ($gSpot1==200){
			print " ya!";
			$xc = $NewNewRibOneXs[$Loop];
			$yc = $NewNewRibOneYs[$Loop];
			$zc = 0;
			}
			
		
		$YrotRibOneXs[$Loop] = sprintf("%.6f",$xc);
		$YrotRibOneYs[$Loop] = sprintf("%.6f",$yc);			
		$YrotRibOneZs[$Loop] = sprintf("%.6f",$zc);
		
		$RibOneMasterX[$Loop] = $YrotRibOneXs[$Loop];
		$RibOneMasterY[$Loop] = $YrotRibOneYs[$Loop];		
		$RibOneMasterZ[$Loop] = $YrotRibOneZs[$Loop];
		
		$ZeroVal = 0;
			
		if (abs($YrotRibOneXs[$Loop]) < abs(.0001)){$YrotRibOneXs[$Loop] = sprintf("%.6f",$ZeroVal);}
		if (abs($YrotRibOneZs[$Loop]) < abs(.0001)){$YrotRibOneZs[$Loop] = sprintf("%.6f",$ZeroVal);}
		
		if ($YrotRibOneXs[$Loop] == 0) {$NewXtest = 6;}
		if ($YrotRibOneZs[$Loop] == 0) {$NewZtest = 6;}
		$YrotTestRibOne[$Loop] = $NewXtest * $NewZtest;
		
		$UseDotRibOne[$Loop] = 0;
		if ($YrotTestRibOne[$Loop] >=36){ $UseDotRibOne[$Loop] = 200;}
		
				if ($gSpot1==200){
			$YrotTestRibOne[$Loop] =36;
			$UseDotRibOne[$Loop] = 200;
			}
		
		$TestCondition = $NewCounter * $UseDotRibOne[$Loop];
        $TestCondOne[$Loop] = $TestCondition;

		
		$NewXtest = 1;
		$NewZtest = 1;
		$NewValTest = 0;

			
			}
			
		print ( "\n" );
					
	for ($Loop = 1; $Loop <= $total1; $Loop++){
		print $HoldDotRibOne[$Loop];
		$HoldDotRibOne[$Loop] = $UseDotRibOne[$Loop];
		print "   ";
		print $HoldDotRibOne[$Loop];
		print "   ";
		print $Loop;
		print "   ";
		print ( $RibOneMasterX[$Loop] . "," . $RibOneMasterY[$Loop] . "," . $RibOneMasterZ[$Loop] . "     "  . $YrotTestRibOne[$Loop] . "  " . $HoldDotRibOne[$Loop] . "\n");
	
				}			
								
print ( "\n" );
print ( "\n" );
###########Rib2
$NewXtest = 1;
$NewZtest = 1;
$NewValTest = 0;

print "rib 2 \n";
	for ($Loop = 1; $Loop <= $total2; $Loop++){
		
				
		$gSpot2 = $HoldDotRibTwo[$Loop];	
		#print $gSpot2;
		
		if ($gSpot2==0){
		#{print " no!";
		}
		
		if ($gSpot2==200){
		#{print " ya!";
		}
		
		#print ( "\n" );
		
		
		
		$xb = $NewNewRibTwoXs[$Loop];
		$yb = $NewNewRibTwoYs[$Loop];
		$zb = $NewNewRibTwoZs[$Loop];
		
			$xc = $zb*sin($yr)+$xb*cos($yr);
			$yc = $yb;
			$zc = $zb*cos($yr)-$xb*sin($yr);
			
			
		if ($gSpot2==200){
			print " ya!";
			$xc = $NewNewRibTwoXs[$Loop];
			$yc = $NewNewRibTwoYs[$Loop];
			$zc = 0;
			}
		
		$YrotRibTwoXs[$Loop] = sprintf("%.6f",$xc);
		$YrotRibTwoYs[$Loop] = sprintf("%.6f",$yc);			
		$YrotRibTwoZs[$Loop] = sprintf("%.6f",$zc);
		
		$RibTwoMasterX[$Loop] = $YrotRibTwoXs[$Loop];
		$RibTwoMasterY[$Loop] = $YrotRibTwoYs[$Loop];		
		$RibTwoMasterZ[$Loop] = $YrotRibTwoZs[$Loop];	
		
		$ZeroVal = 0;
			
		if (abs($YrotRibTwoXs[$Loop]) < abs(.0001)){$YrotRibTwoXs[$Loop] = sprintf("%.6f",$ZeroVal);}
		if (abs($YrotRibTwoZs[$Loop]) < abs(.0001)){$YrotRibTwoZs[$Loop] = sprintf("%.6f",$ZeroVal);}
		
		if ($YrotRibTwoXs[$Loop] == 0) {$NewXtest = 6;}
		if ($YrotRibTwoZs[$Loop] == 0) {$NewZtest = 6;}
		$YrotTestRibTwo[$Loop] = $NewXtest * $NewZtest;
		
		$UseDotRibTwo[$Loop] = 0;
		if ($YrotTestRibTwo[$Loop] >=36){ $UseDotRibTwo[$Loop] = 200;}
		
		if ($gSpot2==200){
			$YrotTestRibTwo[$Loop] =36;
			$UseDotRibTwo[$Loop] = 200;
			}
		
		$TestCondition2 = $NewCounter * $UseDotRibTwo[$Loop];
	 	$TestCondTwo[$Loop] = $TestCondition2;
		
$NewXtest = 1;
$NewZtest = 1;
$NewValTest = 0;
			
			}
			
		for ($Loop = 1; $Loop <= $total2; $Loop++){
			
		print $HoldDotRibTwo[$Loop];
		$HoldDotRibTwo[$Loop] = $UseDotRibTwo[$Loop];
		print "   ";
		print $HoldDotRibTwo[$Loop];
		print "   ";
		print $Loop;
		print "   ";

		print ( $RibTwoMasterX[$Loop] . "," . $RibTwoMasterY[$Loop] . "," . $RibTwoMasterZ[$Loop] . "         "  . $YrotTestRibTwo[$Loop] . "  " . $HoldDotRibTwo[$Loop] . "\n");
		
		}		
			
			
			
			
			
print ( "\n" );
print ( "\n" );
###########Rib3

$NewXtest = 1;
$NewZtest = 1;
$NewValTest = 0;
print "rib 3 \n";

		
		
	for ($Loop = 1; $Loop <= $total3; $Loop++){
		
		$gSpot3 = $HoldDotRibTre[$Loop];	
		#print $gSpot3;
		
		if ($gSpot3==0){
		#{print " no!";
		}
		
		if ($gSpot3==200){
		#{print " ya!";
		}
		
		#print ( "\n" );

			$xb = $NewNewRibTreXs[$Loop];
			$yb = $NewNewRibTreYs[$Loop];
			$zb = $NewNewRibTreZs[$Loop];
		
			$xc = $zb*sin($yr)+$xb*cos($yr);
			$yc = $yb;
			$zc = $zb*cos($yr)-$xb*sin($yr);
			
			if ($gSpot3==200){
			print " ya!";
			$xc = $NewNewRibTreXs[$Loop];
			$yc = $NewNewRibTreYs[$Loop];
			$zc = 0;
			}
		
			$YrotRibTreXs[$Loop] = sprintf("%.6f",$xc);
			$YrotRibTreYs[$Loop] = sprintf("%.6f",$yc);			
			$YrotRibTreZs[$Loop] = sprintf("%.6f",$zc);
			
			
			$RibTreMasterX[$Loop] = $YrotRibTreXs[$Loop];
			$RibTreMasterY[$Loop] = $YrotRibTreYs[$Loop];		
			$RibTreMasterZ[$Loop] = $YrotRibTreZs[$Loop];	
				
		$ZeroVal = 0;
			
		if (abs($YrotRibTreXs[$Loop]) < abs(.0001)){$YrotRibTreXs[$Loop] = sprintf("%.6f",$ZeroVal);}
		if (abs($YrotRibTreZs[$Loop]) < abs(.0001)){$YrotRibTreZs[$Loop] = sprintf("%.6f",$ZeroVal);}
		
		if ($YrotRibTreXs[$Loop] == 0) {$NewXtest = 6;}
		if ($YrotRibTreZs[$Loop] == 0) {$NewZtest = 6;}
		$YrotTestRibTre[$Loop] = $NewXtest * $NewZtest;
		
		$UseDotRibTre[$Loop] = 0;
		if ($YrotTestRibTre[$Loop] >=36){ $UseDotRibTre[$Loop] = 200;}
		
		if ($gSpot3==200){
			$YrotTestRibTre[$Loop] =36;
			$UseDotRibTre[$Loop] = 200;
			}
		
		$TestCondition3 = $NewCounter * $UseDotRibTre[$Loop];	
		$TestCondTre[$Loop] = $TestCondition3;
		
$NewXtest = 1;
$NewZtest = 1;
$NewValTest = 0;	
							
	}
	
		for ($Loop = 1; $Loop <= $total3; $Loop++){
			
		print $HoldDotRibTre[$Loop];
		$HoldDotRibTre[$Loop] = $UseDotRibTre[$Loop];
		print "   ";
		print $HoldDotRibTre[$Loop];
		print "   ";
		print $Loop;
		print "   ";

		print ( $RibTreMasterX[$Loop] . "," . $RibTreMasterY[$Loop] . "," . $RibTreMasterZ[$Loop] . "         "  . $YrotTestRibTre[$Loop] . "  " . $HoldDotRibTre[$Loop] . "\n");					

		}
	
print ( "\n" );
print ( "\n" );

$Increment = $NewCounter + 1 ;

for ($Loop = 1; $Loop <= $total1; $Loop++){
#	print ($Loop . "  " . $RibOneXs[1] . "         " . "\n");
		$TempRibOneXs[$Loop] = $YrotRibOneXs[$Loop] - $YrotRibOneXs[$Increment];
		$TempRibOneYs[$Loop] = $YrotRibOneYs[$Loop] - $YrotRibOneYs[$Increment];
		$TempRibOneZs[$Loop] = $YrotRibOneZs[$Loop] - $YrotRibOneZs[$Increment];
	}

	for ($Loop = 1; $Loop <= $total1; $Loop++){
		$NewRibOneXs[$Loop] = sprintf("%.6f", $TempRibOneXs[$Loop]);
		$NewRibOneYs[$Loop] = sprintf("%.6f", $TempRibOneYs[$Loop]);
		$NewRibOneZs[$Loop] = sprintf("%.6f", $TempRibOneZs[$Loop]);
	}
###############################2
		
for ($Loop = 1; $Loop <= $total2; $Loop++){
#	print ($Loop . "  " . $RibOneXs[1] . "         " . "\n");
		$TempRibTwoXs[$Loop] = $YrotRibTwoXs[$Loop] - $YrotRibOneXs[$Increment];
		$TempRibTwoYs[$Loop] = $YrotRibTwoYs[$Loop] - $YrotRibOneYs[$Increment];
		$TempRibTwoZs[$Loop] = $YrotRibTwoZs[$Loop] - $YrotRibOneZs[$Increment];
	}

	for ($Loop = 1; $Loop <= $total2; $Loop++){
		$NewRibTwoXs[$Loop] = sprintf("%.6f", $TempRibTwoXs[$Loop]);
		$NewRibTwoYs[$Loop] = sprintf("%.6f", $TempRibTwoYs[$Loop]);
		$NewRibTwoZs[$Loop] = sprintf("%.6f", $TempRibTwoZs[$Loop]);
	}

###############################3
	
for ($Loop = 1; $Loop <= $total3; $Loop++){
#	print ($Loop . "  " . $RibOneXs[1] . "         " . "\n");
		$TempRibTreXs[$Loop] = $YrotRibTreXs[$Loop] - $YrotRibOneXs[$Increment];
		$TempRibTreYs[$Loop] = $YrotRibTreYs[$Loop] - $YrotRibOneYs[$Increment];
		$TempRibTreZs[$Loop] = $YrotRibTreZs[$Loop] - $YrotRibOneZs[$Increment];
	}

	for ($Loop = 1; $Loop <= $total3; $Loop++){
		$NewRibTreXs[$Loop] = sprintf("%.6f", $TempRibTreXs[$Loop]);
		$NewRibTreYs[$Loop] = sprintf("%.6f", $TempRibTreYs[$Loop]);
		$NewRibTreZs[$Loop] = sprintf("%.6f", $TempRibTreZs[$Loop]);
	}
###############################print	

print "Done with MasterLoop number   ";
print $NewCounter;
print ( "\n" );print ( "\n" );print ( "\n" );
}

print "Pre Pre DXF";
print ( "\n" );

		for ($Loop = 1; $Loop <= $total3; $Loop++){
			
		print ( $RibTreMasterX[$Loop] . "," . $RibTreMasterY[$Loop] . "," . $RibTreMasterZ[$Loop] . "\n");					

		}
print ( "\n" );
print ( "\n" );

		for ($Loop = 1; $Loop <= $total3; $Loop++){
				if (abs($RibTreMasterZ[$Loop]) < abs(.0001)){
				$RibTreMasterZ[$Loop] = sprintf("%.6f",$ZeroVal);}		
				}

		for ($Loop = 1; $Loop <= $total3; $Loop++){
				$CompRibTreMasterX[$Loop] = $RibTreMasterX[$Loop] * .025400;
				$CompRibTreMasterY[$Loop] = $RibTreMasterY[$Loop] * .025400;
				$CompRibTreMasterZ[$Loop] = $RibTreMasterZ[$Loop] * .025400;								
				}

print "Pre DXF";
print ( "\n" );

		for ($Loop = 1; $Loop <= $total3; $Loop++){	
			print ( $CompRibTreMasterX[$Loop] . "," . $CompRibTreMasterY[$Loop] . "," . $CompRibTreMasterY[$Loop] . "\n");					
			}

print ( "\n" );
print ( "\n" );

open (FILEOUT, ">" . "DXF_LW_test.dxf");

print FILEOUT ("0" . "\n");
print FILEOUT ("SECTION" . "\n");
print FILEOUT ("2" . "\n");
print FILEOUT ("HEADER" . "\n");
print FILEOUT ("999" . "\n");
print FILEOUT ("DXF File Generated by LightWave 3D(TM)" . "\n");
print FILEOUT ("0" . "\n");
print FILEOUT ("ENDSEC" . "\n");
print FILEOUT ("0" . "\n");
print FILEOUT ("SECTION" . "\n");
print FILEOUT ("2" . "\n");
print FILEOUT ("TABLES" . "\n");
print FILEOUT ("0" . "\n");
print FILEOUT ("ENDSEC" . "\n");
print FILEOUT ("0" . "\n");
print FILEOUT ("SECTION" . "\n");
print FILEOUT ("2" . "\n");
print FILEOUT ("BLOCKS" . "\n");
print FILEOUT ("0" . "\n");
print FILEOUT ("ENDSEC" . "\n");
print FILEOUT ("0" . "\n");
print FILEOUT ("SECTION" . "\n");
print FILEOUT ("2" . "\n");
print FILEOUT ("ENTITIES" . "\n");
print FILEOUT ("0" . "\n");

for ($Loop = 1; $Loop <= $total3; $Loop++){
	
	$LoopPlus = $Loop +1;
	
	print FILEOUT ("LINE" . "\n");
	print FILEOUT ("8" . "\n");
	print FILEOUT ("0" . "\n");
	print FILEOUT ("70" . "\n");
	print FILEOUT ("0" . "\n");
	print FILEOUT ("10" . "\n");
		
	print FILEOUT ($CompRibTreMasterX[$Loop] . "\n");
	print FILEOUT ("20" . "\n");
	print FILEOUT ($CompRibTreMasterY[$Loop] . "\n");
	print FILEOUT ("30" . "\n");
	print FILEOUT ($CompRibTreMasterZ[$Loop] . "\n");
	print FILEOUT ("11" . "\n");
	print FILEOUT ($CompRibTreMasterX[$LoopPlus] . "\n");
	print FILEOUT ("21" . "\n");
	print FILEOUT ($CompRibTreMasterY[$LoopPlus] . "\n");
	print FILEOUT ("31" . "\n");
	print FILEOUT ($CompRibTreMasterZ[$LoopPlus] . "\n");
	print FILEOUT ("0" . "\n");
}

print FILEOUT ("ENDSEC" . "\n");
print FILEOUT ("0" . "\n");
print FILEOUT ("EOF" . "\n");





__END__
:endofperl