-- ArchiFrame BTL cnc-writer
-- See www.lua.org for Lua manual.
-- Extension functions - see manual


---------------------------------------------------------------------------
-- CODE SHARED WITH ARCHIFRAME START -->

EPS=0.0001
PI=3.141592653589793
PI2=PI/2.0
PI180=PI/180.0
PI1800=PI/1800.0

-- # Frame machinings types
EMcFrAngledBegOld	= 100
EMcFrAngledBeg		= 101
EMcFrAngledBegTenon = 110		-- Also dovetail
EMcFrBegHiddenShoe	= 111
EMcVCutBeg			= 114
EMcFrAngledEndOld	= 200
EMcFrAngledEnd		= 201
EMcFrAngledEndTenon	= 210
EMcFrEndHiddenShoe	= 211
EMcVCutEnd			= 214

EMcFrOpening		= 300		-- Opening - unused now
EMcFrGroove			= 301		-- Logsin tapainen vapaa ura
EMcFrDrill			= 302		-- Drilling
EMcFrMarking		= 303		-- Marking
EMcFrReinforce		= 304
EMcFrSaw			= 305
EMcFrNailGroup		= 306
EMcFrNailLine		= 307

EMcFrTenonSide		= 400		-- Also dovetail
EMcFrBalkJoint		= 401		-- Narrowed balk

EMcFrBalkShoe		= 1000

---------------------------------------------------------------------------
-- ARCHIFRAME & ARCHILOGS COMMON FUNCTIONS

function toLog(str)
	AddCncErr( 0, str )
end


-- Dumps given variable into string
function DumpTblInt(o)
  local s
  
  if type(o) == 'table' then
    s = '{ '
    for k,v in pairs(o) do
      if type(k) ~= 'number' then k = '"'..k..'"' end
      s = s .. '['..k..'] = ' .. DumpTblInt(v) .. ','
    end
    s=s .. '} '
  else
    s=tostring(o)
  end
  return s
end


function DumpTbl(o)
  ac_environment("tolog", DumpTblInt(o))
end


-- Returns 32bit binary number string "010011100..."
function NumToBin(nVal)
	local	nExp, sBin
	
	nExp=2147483648
	sBin=""
	repeat
		if nVal+0.1>=nExp then
			nVal=nVal-nExp
			sBin=sBin .. "1"
		else
			sBin=sBin .. "0"
		end	
		
		nExp=nExp/2
	until nExp<0.9
	
	if string.len(sBin)~=32 then
		error( "NumToBin failed" )
	end

	return sBin
end


function BitTest(nVal, nBit0based)
	local	s, s2
	
	s=NumToBin(nVal)
	s2=string.sub(s, 32-nBit0based, 32-nBit0based)
	if s2=="0" then
		return 0
	end
	if s2=="1" then
		return 1
	end

	error( string.format("BitTest failed (s=%s, s2=%s)", s, s2) )
end


-- Removes spaces from beg and end
function TrimStr(str)
	local	res, start, endIndex, len

	len=string.len(str)
	start=1
	while start<=len and string.sub(str,start,start)==" " do
		start=start+1
	end

	endIndex=len
	while endIndex>0 and string.sub(str,endIndex,endIndex)==" " do
		endIndex=endIndex-1
	end
	
	return string.sub(str,start, endIndex)
end


-- Aiheuttaa virheilmoituksen, jonka Logs osaa tulkita k�ytt�j�lle n�ytett�v�ksi viestiksi
-- Ilmoitus voi olla tyhj�, jolloin ei n�ytet� mit��n (peruttu)
function RaiseError(msg)
	msg="###>" ..  msg .. "<###"
	error( msg )
end

gnCncErrCount=0			-- Notices for the log

-- Adds cnc error message to gTblCncErr
function AddErrMsg(sLogId, nPos, sText)
	if nPos==nil then error("AddCncErr/nPos") end
	if sText==nil then error("AddCncErr/sText") end

	if gnCncErrCount==0 then
		gTblCncErr={}
	end

	gnCncErrCount=gnCncErrCount+1
	gTblCncErr[gnCncErrCount] = {}
	gTblCncErr[gnCncErrCount].guid=gsCurrentLogGuid
	gTblCncErr[gnCncErrCount].logid=sLogId
	gTblCncErr[gnCncErrCount].pos=nPos
	gTblCncErr[gnCncErrCount].text=sText
end



-- Adds cnc error message to gTblCncErr
function AddCncErr(nPos, sText)
	AddErrMsg(gsCurrentLogId, nPos, sText)
end


gtblUsedIds = {}				-- T�nne asetetaan ["id"]=1, ett� l�ydet��n samalla ID:ll� olevat hirret

function CheckId( sId )
	if sId=="" then
		AddCncErr( 0, string.format("LOG/FRAME EMPTY ID FOUND") )
	elseif gtblUsedIds[sId]~=null then
		AddCncErr( 0, string.format("LOG/FRAME ID %s USED AT LEAST TWICE", sId) )
	else
		gtblUsedIds[sId]=1
	end
end


-- User entered values may be small if millimeters were used
function NormalizeType(nNum)
	if math.abs(nNum)<0.1 then
		nNum=math.floor(nNum*1000+0.5)
	end
	return nNum
end


---------------------------------------------------------------------------
-- ARCHIFRAME & ARCHILOGS GEOMETRY FUNCTIONS

-- ### Alustaa muuttujan tranTbl[] py�ritt�m��n ja siirt�m��n pistett�
-- Katso http://gregs-blog.com/category/3d-mathematics/
-- in:
-- 	vecX,vecY,vecZ	Vektori, jonka ymp�rill� py�ritell��n. Yksikk�vektori!!
-- 	addX,addY,addZ	Siirto
-- 	angle			Py�rityskulma
-- out:
--	tranTbl[12]
function Rotate3Dinit(vecX, vecY, vecZ, addX, addY, addZ, angle)
	local	cosAngle, sinAngle, ucosAngle, tranTbl

	cosAngle=math.cos(angle)
	sinAngle=math.sin(angle)
	ucosAngle=1-cosAngle
	tranTbl={}

	-- Tehd��n yksikk�vektori
	--_ulen=1/sqr(vecX*vecX+vecY*vecY+vecZ*vecZ)
	--vecX=vecX*_ulen
	--vecY=vecY*_ulen
	--vecZ=vecZ*_ulen

	tranTbl[1]=ucosAngle*vecX*vecX+cosAngle
	tranTbl[2]=ucosAngle*vecX*vecY-vecZ*sinAngle
	tranTbl[3]=ucosAngle*vecZ*vecX+vecY*sinAngle
	tranTbl[4]=addX

	tranTbl[5]=ucosAngle*vecX*vecY+vecZ*sinAngle
	tranTbl[6]=ucosAngle*vecY*vecY+cosAngle
	tranTbl[7]=ucosAngle*vecY*vecZ-vecX*sinAngle
	tranTbl[8]=addY

	tranTbl[9]=ucosAngle*vecZ*vecX-vecY*sinAngle
	tranTbl[10]=ucosAngle*vecY*vecZ+vecX*sinAngle
	tranTbl[11]=ucosAngle*vecZ*vecZ+cosAngle
	tranTbl[12]=addZ

	--tranTbl[13]=0
	--tranTbl[14]=0
	--tranTbl[15]=0
	--tranTbl[16]=1
	return tranTbl
end


-- ### Py�ritt�� 3D-pistett� annetun vektorin ymp�ri. Kutsu Rotate3Dinit ennen t�t�.
-- in:
-- xin, yin, zin
-- out:
-- x, y, z
function Rotate3D(tranTbl, xin, yin, zin)
	local	x, y, z
	
	x=tranTbl[1]*xin + tranTbl[2]*yin + tranTbl[3]*zin	+ tranTbl[4]
	y=tranTbl[5]*xin + tranTbl[6]*yin + tranTbl[7]*zin + tranTbl[8]
	z=tranTbl[9]*xin + tranTbl[10]*yin + tranTbl[11]*zin + tranTbl[12]
	return x,y,z
end



-- ### Py�ritt�� 3D-pistett� annetun vektorin ymp�ri pit�en edellisen Rotate3DInit-arvot kuosissa
-- in:
-- xin, yin, zin, angle
-- vecX, vecY, vecZ	Mink� vektorin ymp�ri py�ritell��n
-- out:
-- _x, _y, _z
function RotateSingle3D(xin, yin, zin, vecX, vecY, vecZ, angle)
	local	x, y, z, tranTbl

	tranTbl = Rotate3Dinit(vecX, vecY, vecZ, 0, 0, 0, angle)
	x,y,z=Rotate3D(tranTbl,xin, yin, zin)
	return x,y,z
end



-- Calculates cross product of two vectors
-- Katsele http://en.wikipedia.org/wiki/Cross_product: On se suunta t�ll�kin tiedossa: vec1 on oikean k�den etusormi, vec2 keskari ja refRes on sitten peukalo yl�s
-- returns x,y,z
function CalcCross3D( x1, y1, z1, x2, y2, z2 )
	local x,y,z
	
	x = y1 * z2 - z1 * y2
	y = z1 * x2 - x1 * z2
	z = x1 * y2 - y1 * x2
	return x,y,z
end


-- Sets len to 1
-- Returns x,y,z,bOkVec (true/false=zero len)
function ToUnitVec3(x, y, z)
	local	d
	
	d=math.sqrt(x*x+y*y+z*z)
	if d<0.0001 then
		return 0,0,0,false
	end
	d=1/d
	return x*d,y*d,z*d,true
end


-- Duunaa tason yht�l�n ax+bx+cx+dx=0 tason normaalista ja yhdest� pisteest� x1,y1,z1
-- Huom-- plane constant eri etumerkill� kuin wykobissa
-- in:
--	tnx, tny, tnz	Vektori tason normaalista, lasketaan t��ll� yksikk�vektoriksi
--	x1,y1,z1		Piste tasolla
-- out:
--	ta, tb, tc, td	Tason yht�l� (ta,tb,tc=tnx,tny,tnz normalisoituna)
function MakePlaneNormal(tnx, tny, tnz, x1, y1, z1)
	--   template<typename T>
	--   inline plane<T,3> make_plane(const T& x1, const T& y1, const T& z1,
	--								const T& x2, const T& y2, const T& z2,
	--								const T& x3, const T& y3, const T& z3)
	--   {
	--	  plane<T,3> plane_;
	--	  vector3d<T> v1 = makevector(x2 - x1, y2 - y1, z2 - z1);
	--	  vector3d<T> v2 = makevector(x3 - x1, y3 - y1, z3 - z1);
	--	  plane_.normal   = normalize(v1 * v2);
	--	  plane_.constant = dot_product(plane_.normal,makevector(x1,y1,z1));
	--	  return plane_;
	--   }
	local mul, ta, tb, tc, td

	-- T�ss� hyp�t��n suoraan vakion laskentaan
	mul=1/math.sqrt(tnx*tnx+tny*tny+tnz*tnz)
	ta=tnx*mul
	tb=tny*mul
	tc=tnz*mul
	td=-(ta*x1+tb*y1+tc*z1)
	return ta, tb, tc, td
end



-- ### Suoran ja tason leikkauspiste
-- in: 
--	ta,tb,tc,td		Tason yht�l�, a-c=kohtisuora ja d on vakio
--   x1, y1, z1		Suora
--   x2, y2, z2		Suora
-- out:
--	hasX			Oliko leikkausta
--	x, y, z			Piste
--   dist			Et�isyys pisteest� x1,y1,z1 suoran suuntaisesti
function LinePlaneX(ta, tb, tc, td, x1, y1, z1, x2, y2, z2 )
	-- Tuollainen koodi "k��nnetty" wykobi-kirjastosta
	--   template<typename T>
	--   inline point3d<T> intersection_point(const line<T,3>&  line,
	--										const plane<T,3>& plane)
	--   {
	--	  vector3d<T> linevec = line[1] - line[0];
	--	  T denom = dot_product(linevec,plane.normal);
	--	  point3d<T> ipoint = degenerate_point3d<T>();
	--	  if (not_equal(denom,T(0.0)))
	--	  {
	--		 T t = -distance(line[0],plane) / denom;
	--		 ipoint = line[0] + t * (line[1] - line[0]);
	--	  }
	--	  return ipoint;
	--   }
	local x, y, z, dist, denom


	dist=0

	x=x2-x1
	y=y2-y1
	z=z2-z1

	denom=x*ta + y*tb + z*tc		-- Pistetulo suora ja tason normaali
	if math.abs(denom)<1E-5 then
		-- Tason suuntainen suora
		return false
	end

	-- Pisteen et�isyys tasolta
	-- (plane.normal.x * point.x + plane.normal.y * point.y + plane.normal.z * point.z ) - plane.constant;

	dist=-(ta*x1 + tb*y1 + tc*z1 + td)/denom		-- Huom-- td eri etumerkill� kuin wykobissa (kun siell� oli puki)
	x=x1 + x*dist
	y=y1 + y*dist
	z=z1 + z*dist
	return true, x, y, z, dist
end

-- Returns unit vector 90 degrees left x,y for given vector
function GetUnitVecLeft(x, y)
	local	len
	
	len=math.sqrt(x*x+y*y)
	if len<EPS then
		return 0,0
	end
	return -y/len,x/len
end


function GetDist( x1, y1, x2, y2 )
	x2=x2-x1
	y1=y2-y1
	return math.sqrt(x2*x2+y2*y2)
end


function GetSqr(x)
	return x*x
end


-- Laskee viistetyn kapulan päälle, paljonko viisteystasoa pitää siirtää sisäänpäin kapulaa, että leikkaisi oikein.
-- in:
--	tasoTbl[n][4]
--	tasoCount
-- out:
--	cutOffsets[5], [5]=refviiva
--	maxEt
function CutEndingWithPlanes(tasoTbl, tasoCount, width, height)
	local taso, cutOffsets, maxEt, yoff, zoff, x1, y1, z1, x2, y2, z2, ta, tb, tc, td
	local hasX, x, y, z, dist

	cutOffsets={}
	
	-- Nurkkapisteet
	yoff={}
	zoff={}
	
	yoff[1]=width*0.5
	zoff[1]=0

	yoff[2]=width*0.5
	zoff[2]=height

	yoff[3]=-width*0.5
	zoff[3]=height

	yoff[4]=-width*0.5
	zoff[4]=0
	
	yoff[5]=0
	zoff[5]=0
	
	for i=1,5 do
		cutOffsets[i]=1E10
	end

	-- Lasketaan paljonko kauimmainen pää jää tasosta (antaa keskipisteen tulla mukaan laskentaan)
	maxEt=0
	for taso=1, tasoCount do
		for i=1,5 do
			x1=0
			y1=yoff[i]
			z1 = zoff[i]
			x2=-1
			y2=y1
			z2=z1
			ta=tasoTbl[taso][1]
			tb=tasoTbl[taso][2]
			tc=tasoTbl[taso][3]
			td=tasoTbl[taso][4]
			hasX, x, y, z, dist = LinePlaneX(ta, tb, tc, td, x1, y1, z1, x2, y2, z2 )
			
			if hasX then
				-- Pitäisi aina olla, mutta... Haetaan sis lähin taso jokaiselle pisteelle
				if dist<cutOffsets[i] then 
					cutOffsets[i]=dist
				end
			end
		end
	end

	maxEt=-1e10
	for i=1,5 do
		if cutOffsets[i]>maxEt then 
			maxEt=cutOffsets[i]
		end
	end

	return cutOffsets, maxEt
end


-- Calculates intersection of two infinite lines
-- Line1 is (x1,y1)->(x2,y2) and line2 is (x3,y3)->(x4,y4)
-- See http://local.wasp.uwa.edu.au/~pbourke/geometry/lineline2d/
-- Returns three values:
-- 1. bool, true=has intersection
-- 2. number, x
-- 3. number, y
function GetLinesX( x1, y1, x2, y2, x3, y3, x4, y4 )
	local ua, divisor

	divisor=(y4-y3)*(x2-x1)-(x4-x3)*(y2-y1)
	if math.abs(divisor)<EPS then
		return false,0,0
	end

	ua=((x4-x3)*(y1-y3)-(y4-y3)*(x1-x3))/divisor
	return true, x1+ua*(x2-x1), y1+ua*(y2-y1)
end

-- GEOMETRY FUNCTIONS
---------------------------------------------------------------------------


-----------------------------------------------------------------------------
--                      BTL CODE                                           --
-----------------------------------------------------------------------------


-- Which side of the log is against the machine's base plate (not the table, suomeksi "vaste")
EBtlMale=0				-- Log top
EBtlFrontSide=1
EBtlFemale=2			-- Log bottom
EBtlBackSide=3
gnBtlPlateSide=EBtlFrontSide		-- Actually which side is towards user in btlviewer

-- Which end goes first to the machine
EBtlDirBeg=0
EBtlDirEnd=1
gnBtlLogDir=EBtlDirBeg	-- Also for AF plank

-- Settings
gnBtlYoffset=0					-- Value to add to y-coordinate (in faces 2,4) to get current log's/plank's bottom. May be negative if overlap is below the piece.



-- Hundegger writer globals
gnBtlPieceNum=1					-- Global piece number



-- K��nt�� jos menee loppu edell�
function BtlGetXc(nCoord)
	if gnBtlLogDir==EBtlDirBeg then
		return nCoord
	end
	return gnCurrTotLen-nCoord
end


function BtlMirrorYc(nCoord, logFace)
	if logFace==1 or logFace==3 then
		return gnCurrWidth - nCoord
	end
	
	return gnProfHeight - nCoord
end


-- Returns +-1...4 for the log's beginning head (left side) depending on gnBtlLogDir and side
-- Second value: bool to mirror x-coordinates for the end face OK ONLY IF USING FACE 3 (bottom)
-- Third value: bool to mirror y-coordinates
function BtlGetLogBegBvnSide(logFace)
	local	nBtlSide, mirrorX, mirrorY

	mirrorX=false
	mirrorY=false
	nBtlSide=BtlGetSide14(logFace)
	if gnBtlLogDir==EBtlDirEnd then
		error("unsupported feed dir")
		nBtlSide=-nBtlSide
	else
		mirrorX=true
	end
	return nBtlSide, mirrorX, mirrorY
end


-- Returns +-1...4 for the log's end head (right side) depending on gnBtlLogDir and side
function BtlGetLogEndBvnSide(logFace)
	local	face, mirrorX, mirrorY

	face, mirrorX, mirrorY = BtlGetLogBegBvnSide(logFace)
	return -face, mirrorX, mirrorY
end

-- For BvnGetSide, first index is ArchiLogs side 1...4 (top, front, bottom, back), second is the log side towards the user in btlviewer (EBtlFemale etc), third is direction EBtlDirBeg/end
gBtlSides={
	-- log top
	-- FEEDING END FIRST IS NOT DONE SINCE IT IS NOT SUPPORTED NOW
	[1] = { 
			[EBtlMale]		= { [EBtlDirBeg]={1, false},	[EBtlDirEnd]={4, false} },
			[EBtlFrontSide]	= { [EBtlDirBeg]={4, false},	[EBtlDirEnd]={3, false} },
			[EBtlFemale]	= { [EBtlDirBeg]={3, false},	[EBtlDirEnd]={2, false} },	
			[EBtlBackSide]	= { [EBtlDirBeg]={2, false},	[EBtlDirEnd]={1, false} }
		  },

	-- log front
	[2] = {
			[EBtlMale]		= { [EBtlDirBeg]={2, false},	[EBtlDirEnd]={1, false} },
			[EBtlFrontSide]	= { [EBtlDirBeg]={1, false},	[EBtlDirEnd]={4, false} },
			[EBtlFemale]	= { [EBtlDirBeg]={4, false},	[EBtlDirEnd]={3, false} },
			[EBtlBackSide]	= { [EBtlDirBeg]={3, false},	[EBtlDirEnd]={2, false} }
		  },

	-- log bottom
	[3] = { 
			[EBtlMale]		= { [EBtlDirBeg]={3, true},	[EBtlDirEnd]={2, true } },
			[EBtlFrontSide]	= { [EBtlDirBeg]={2, true},	[EBtlDirEnd]={1, true} },
			[EBtlFemale]	= { [EBtlDirBeg]={1, true},	[EBtlDirEnd]={4, true} },
			[EBtlBackSide]	= { [EBtlDirBeg]={4, true},	[EBtlDirEnd]={3, true} }
		  },

	-- log back
	[4] = {
			[EBtlMale]		= { [EBtlDirBeg]={4, true},	[EBtlDirEnd]={3, true } },
			[EBtlFrontSide]	= { [EBtlDirBeg]={3, true},	[EBtlDirEnd]={2, true} },
			[EBtlFemale]	= { [EBtlDirBeg]={2, true},	[EBtlDirEnd]={1, true} },
			[EBtlBackSide]	= { [EBtlDirBeg]={1, true},	[EBtlDirEnd]={4, true} }
		  }
}


-- Returns two values:
-- first: bvn side is: 1=top, 2=not against plate, 3=bottom against the table, 4=against the plate
-- second: true=need to mirror coordinates in y-direction, false=nope. x-direction must be swapped if gnBtlLogDir==EBtlDirEnd
function BtlGetSide14(logFace)
	return gBtlSides[logFace][gnBtlPlateSide][gnBtlLogDir][1], gBtlSides[logFace][gnBtlPlateSide][gnBtlLogDir][2]
end


-- BTL BTL BTL BTL BTL BTL BTL BTL BTL BTL BTL BTL BTL BTL BTL BTL BTL
-- BTL BTL BTL BTL BTL BTL BTL BTL BTL BTL BTL BTL BTL BTL BTL BTL BTL


local function ToBtl(s)
	s=string.gsub(s, "\"", "")
	return s
end


-- Adds cnc position and content to table. Table will be sorted at the end.
function BtlAddMc(nPos, sText)
	local	i

	if nPos==nil then error("BtlAddMc/nPos") end
	if sText==nil then error("BtlAddMc/sText") end

	if gnCncCount==0 then
		gTblCnc={}
	end

	gnCncCount=gnCncCount+1
	gTblCnc[gnCncCount] = {}
	gTblCnc[gnCncCount].pos	=nPos
	gTblCnc[gnCncCount].count	=gnCncCount
	gTblCnc[gnCncCount].text	=sText
end


-- THIS IS FOR BACKWARDS COMPATIBILITY & FOR LOG OBJECT FROM 3/2012
-- Side is tilted to front/back face, Top is to top/bottom
-- Angles: 90deg=straight. All rules from log object
-- xc: in plank's coordinates (total length or 0)
-- nBegEnd: +-3
function BtlAddBegEndAngledOld( sPieceNum, nAngleSide, nStraightSide, nAngleTop, nStraightTop, xc, nBegEnd )
	AddCncErr( 0, "ERROR: OLD ANGLED CUTS NOT SUPPORTED - SKIPPED" )
end


-- Adds angled ending to beginning
function BtlAddBegAngledOld( sPieceNum, nAngleSide, nStraightSide, nAngleTop, nStraightTop )
	BtlAddBegEndAngledOld( sPieceNum, nAngleSide, nStraightSide, nAngleTop, nStraightTop, 0, 3 )
end


function BtlAddEndAngledOld( sPieceNum, nAngleSide, nStraightSide, nAngleTop, nStraightTop )
	BtlAddBegEndAngledOld( sPieceNum, nAngleSide, nStraightSide, nAngleTop, nStraightTop, gnCurrTotLen, -3 )
end


-- Table 
gBtlCutAdjustAngleTbl={
	[EBtlMale]		= { [EBtlDirBeg]=false,	[EBtlDirEnd]=true },
	[EBtlFrontSide]	= { [EBtlDirBeg]=false,	[EBtlDirEnd]=false },
	[EBtlFemale]	= { [EBtlDirBeg]=true,	[EBtlDirEnd]=false },
	[EBtlBackSide]	= { [EBtlDirBeg]=true,	[EBtlDirEnd]=true }
}

-- NEW ANGLED ENDING STARTING FROM 3/2012 FOR iMc
-- Angles: As for 101 in plank object
-- xoff,yff,zoff: Offset from the plank end refline, y-offset must have been set to zoff
-- mcIndex:	Machining index 1-based
-- Returns isBeg perhaps set to true if moved a cut from end to begin
function BtlAddBegEndAngled( sPieceNum, nAngle, nBevel, xoff, yoff, zoff, isBeg, mcIndex )
	local xc, yc, nBegEnd, nBtlSide
	local temp
	local bMirrorY,bMirrorTopY

	if isBeg then
		xc=xoff
		nBegEnd=2
	else
		xc=gnCurrTotLen-xoff
		nBegEnd=1
	end

	xc=BtlGetXc(xc)
	if gnBtlLogDir==EBtlDirEnd then
		error( "BAD DIR" )
		--nAngle=PI-nAngle
	end

	-- Anchor to bottom side	
	nBtlSide,bMirrorY=BtlGetSide14(3)

	--if bMirrorY then
		--nBevel=PI-nBevel
		--zoff=gnProfHeight-zoff
	--end

	yoff=yoff+gnCurrWidth*0.5					-- 0=back side side, width=front side
	if bMirrorY then
		yoff=gnCurrWidth-yoff
		nAngle=PI-nAngle
	end

	-- Check if full plank cut
	local	tblInfo, tblRes

	tblInfo={}

	tblInfo.guid = gsCurrentLogGuid
	tblInfo.mcindex = mcIndex
	tblRes = af_request("mc_getcutinfo", tblInfo)

	if tblRes.fullcut==1 or true then
		-- Request by Norsk Modul 10/2021: Move to begin if at the end and cuts the whole plank
		if not isBeg and math.abs(nAngle-PI2)<PI180 and math.abs(nBevel-PI2)>PI180 and nBevel>=-PI1800 then
			-- Just bevel cut (and not 90 deg +-1 deg), check if it reaches begin
			local dx, dy

			dx=gnCurrTotLen-xoff
			dy=dx*math.abs(math.tan(nBevel))
			if nBevel<PI2 then
				-- Cut above zoff
				if dy<gnCurrHeight-zoff+EPS then
--toLog("SWAP1")
					xc=xoff
					nBegEnd=2
					zoff=zoff+dy
					nBevel=PI-nBevel		-- Will cut below zoff
					isBeg=true
				end
			else
				-- Cut below zoff
				if dy<zoff+EPS then
--toLog("SWAP2")
					xc=xoff
					nBegEnd=2
					zoff=zoff-dy
					nBevel=PI-nBevel		-- Will cut above zoff
					isBeg=true
				end
			end
		end

		s = string.format(	"PROCESSKEY:  %d-010-%d        CUT\n" ..
							"PROCESSPARAMETERS: P01:%08.0f P02:%08.0f P03:%08.0f P06:%08.0f P07:%08.0f",
							nBegEnd,						-- X-010-1
							nBtlSide,						-- 1-010-X
							xc * 10000.0,					-- P01
							yoff * 10000.0,					-- P02
							zoff * 10000.0,					-- P03
							nAngle / PI * 1800,				-- P06
							nBevel / PI * 1800				-- P07
						  )
	else
		local	angleBottom, depth, len, x2, y2, dx, dy

AddCncErr( 0, "013 NOT TESTED" )
		--DumpTbl(tblRes)
		nBtlSide,bMirrorY=BtlGetSide14(tblRes.side1)

		xc		=tblRes.x1
		yc		=tblRes.y1
		x2		=tblRes.x2
		y2		=tblRes.y2
		
		--nAngle	=tblRes.btl_p06
		nBevel	=PI-tblRes.btl_p07
		angleBottom	=tblRes.btl_p08
		depth	=tblRes.btl_p11
		len		=tblRes.btl_p12

		dx=x2-xc
		dy=y2-yc
		if bMirrorY then
			yc=BtlMirrorYc(yc, tblRes.side1)
			dy=-dy
			--nBevel=PI-nBevel
		end
		nAngle=math.atan2( dy, dx )
		nAngle=PI-nAngle
		if nAngle>PI then
			nAngle=-2*PI+nAngle
		elseif nAngle<-PI then
			nAngle=2*PI+nAngle
		end

		s = string.format(	"PROCESSKEY:  %d-013-%d        SAW CUT\n" ..
							"PROCESSPARAMETERS: P01:%08.0f P02:%08.0f P03:00000000 P06:%08.0f P07:%08.0f P08:%08.0f P11:%08.0f P12:%08.0f",
							4,								-- X-013-1
							nBtlSide,						-- 1-013-X
							xc * 10000.0,					-- P01
							yc * 10000.0,					-- P02
							nAngle / PI * 1800,				-- P06
							nBevel / PI * 1800,				-- P07
							angleBottom / PI * 1800,		-- P08
							depth * 10000.0,				-- P11
							len * 10000.0					-- P12
						  )
	end

	BtlAddMc( xc, s )
	return isBeg
end


-- Rotates refline to next side
function BtlGroRotateToNext(x1, y1, x2, y2, groDepth, groWidth, groAngle, groAngleLen)
	local	tblGro

	tblGro={}
	tblGro.guid	= gsCurrentLogGuid
	tblGro.x1	= x1
	tblGro.y1	= y1
	tblGro.x2	= x2
	tblGro.y2	= y2
	tblGro.depth	= groDepth
	tblGro.width	= groWidth
	tblGro.groAngleRad	= groAngle
	tblGro.face			= groFace
	tblGro.groTiltAngleRad	= groAngleLen

	af_request("mc_rotgro", tblGro)
	return tblGro.x1, tblGro.y1, tblGro.x2, tblGro.y2, tblGro.depth, tblGro.width, tblGro.groAngleRad, tblGro.groTiltAngleRad
end


-- Changes dir of refline (FrameMc.cpp)
function BtlGroSwapDir(x1, y1, x2, y2, groDepth, groWidth, groAngle, groAngleLen)

	local x, y, d, dx, dy, groLen
	local nx1, ny1, nx2, ny2, ngroDepth, ngroAngle, ngroAngleLen


	dx=x2-x1
	dy=y2-y1
	groLen = math.sqrt( dx*dx + dy*dy )		-- T�m� on uran pituus pinnassa, pohjalla voi olla pienempi
	
	nx1 = x2
	ny1 = y2
	nx2 = x1
	ny2 = y1

	-- Pitkitt�iskallistuksen vaikutus, pos tiltAngle syvent�� uraa
	ngroDepth		= groDepth + groLen * math.sin(groAngleLen)
	ngroAngle		= groAngle;
	ngroAngleLen	= -groAngleLen

	return nx1, ny1, nx2, ny2, ngroDepth, groWidth, ngroAngle, ngroAngleLen
end


-- Calculates parameters for middle line
function BtlGroCalcMid(x1, y1, x2, y2, groDepth, groWidth, groAngle, groAngleLen)

	local x, y, d
	local nx1, ny1, nx2, ny2, ngroDepth, ngroWidth, ngroAngle, ngroAngleLen


	nx1, ny1, nx2, ny2, ngroDepth, ngroWidth, ngroAngle, ngroAngleLen = BtlGroRotateToNext(x1, y1, x2, y2, groDepth, groWidth, groAngle, groAngleLen)
	nx1, ny1, nx2, ny2, ngroDepth, ngroWidth, ngroAngle, ngroAngleLen = BtlGroRotateToNext(nx1, ny1, nx2, ny2, ngroDepth, ngroWidth, ngroAngle, ngroAngleLen)
	nx1, ny1, nx2, ny2, ngroDepth, ngroWidth, ngroAngle, ngroAngleLen = BtlGroSwapDir(nx1, ny1, nx2, ny2, ngroDepth, ngroWidth, ngroAngle, ngroAngleLen)

	return (nx1+x1)*0.5, (ny1+y1)*0.5, (nx2+x2)*0.5, (ny2+y2)*0.5, (ngroDepth + groDepth)*0.5, groWidth, groAngle, groAngleLen
end


-- Adds groove as birds mouth if possible
-- Returns: true=saved, false=not saved
function BtlAddGroAsBird(sPieceNum, x1, y1, x2, y2, groDepth, groWidth, groAngle, groFace, groAngleLen)
	local d, dxDir, dyDir, dzDir, dxDown, dyDown, dzDown, dxBot, dyBot, dzBot, yBot2
	local x,y,z, xBot, yBot, zBot, nAngle7, nAngle8, nBegEnd, faceDy

	--AddCncErr( x1, string.format("x1=%f, y1=%f, x2=%f, y2=%f, groDepth=%f, groWidth=%f, groAngle=%f, groAngleLen=%f", x1, y1, x2, y2, groDepth, groWidth, groAngle, groAngleLen) )
	-- Not to beg/end
	if groFace>4 then
		return false
	end

	-- Must be tilted and lengthwise IS supported
	if math.abs(groAngle)<PI/180 then   --or math.abs(groAngleLen)>PI/180 then
		return false
	end
	
	local tblGroInfo, tblGro


	tblGro={}
	tblGro.guid	= gsCurrentLogGuid
	tblGro.x1	= x1
	tblGro.y1	= y1
	tblGro.x2	= x2
	tblGro.y2	= y2
	tblGro.depth	= groDepth
	tblGro.width	= groWidth
	tblGro.groAngleRad	= groAngle
	tblGro.face			= groFace
	tblGro.groTiltAngleRad	= groAngleLen

	if y1>y2 then
		-- To have positive angle
		af_request("mc_swapgroref", tblGro)
		x1	= tblGro.x1
		y1	= tblGro.y1
		x2	= tblGro.x2
		y2	= tblGro.y2
		groDepth	= tblGro.depth
		groAngle	= tblGro.groAngleRad
		groAngleLen	= tblGro.groTiltAngleRad
	end

	tblGroInfo = af_request("mc_getgroinfo", tblGro)

	if tblGroInfo==nil or tblGroInfo.isBird==false then
		return false
	end

	-- On surface, z neg=inside the plank
	dxDir=(x2-x1)
	dyDir=(y2-y1)
	dzDir=0
	dxDir,dyDir,dzDir,d=ToUnitVec3(dxDir,dyDir,0)
	if d==false then
		return false
	end

	-- To left from surface
	dxBot,dyBot,dzBot=RotateSingle3D(-dyDir, dxDir, 0, dxDir, dyDir, 0, groAngle)
	dxDir,dyDir,dzDir=RotateSingle3D(dxDir, dyDir, 0, dxBot,dyBot,dzBot, groAngleLen)
	dxDown,dyDown,dzDown=CalcCross3D(dxBot, dyBot, dzBot, dxDir, dyDir, dzDir)
	
	--ac_msgbox(string.format("dxDir=%f, dyDir=%f, dzDir=%f, dxDown=%f, dyDown=%f, dzDown=%f, dxBot=%f, dyBot=%f, dzBot=%f", dxDir, dyDir, dzDir, dxDown, dyDown, dzDown, dxBot, dyBot, dzBot))

	-- Calculate groove bottom
	local	angleBeg, angleEnd
	local   xBot1, yBot1, zBot1, xBot2, yBot2, zBot2
	local	nLeft, begZ, endZ

	xBot1=x1+dxDown*groDepth
	yBot1=y1+dyDown*groDepth
	zBot1=0-dzDown*groDepth

	xBot2=xBot1+dxBot*groWidth
	yBot2=yBot1+dyBot*groWidth
	zBot2=zBot1-dzBot*groWidth

	--AddCncErr(0, string.format("xBot1=%f yBot1=%f zBot1=%f xBot2=%f yBot2=%f zBot2=%f", xBot1, yBot1, zBot1, xBot2, yBot2, zBot2))

	--AddCncErr( x1, string.format("x1=%f, y1=%f, x2=%f, y2=%f, groDepth=%f, groWidth=%f, groAngle=%f, groAngleLen=%f", x1, y1, x2, y2, groDepth, groWidth, groAngle, groAngleLen) )

	-- Calc side projection angles (valid angle for birdmouth 1...89 deg)
	nBegEnd=4
	if tblGroInfo.birdBegCutFace==2 then
		angleBeg=math.atan2(dzBot, -dxBot)			-- Positive if cutting the wood (should be always). This is on plank side surface - not on the groove.
		xBot=xBot1
		yBot=yBot1
		zBot=zBot1
	else
		angleBeg=math.atan2(-dzDown, dxDown)
		xBot=xBot2
		yBot=yBot2
		zBot=zBot2
	end
	
	if tblGroInfo.birdEndCutFace==2 then
		angleEnd=math.atan2(-dzBot, -dxBot)			-- Positive if cutting the wood (should be always)
	else
		angleEnd=math.atan2(-dzDown, -dxDown)
	end

	if angleBeg<PI/180 or angleBeg>PI*89/180 or angleEnd<PI/180 or angleEnd>PI*89/180 then
		-- Can be v-cut
		return false
	end
	
	if groAngle>0 then
		nAngle7=PI2-groAngle
		nAngle8=nAngle7+PI2
	else
		nAngle7=-groAngle
		nAngle8=nAngle7+PI2
	end

	if nAngle7<PI/180 or nAngle7>PI*89/180 or nAngle8<PI*91/180 or nAngle8>PI-PI/180 then
		-- Prev check should disable this
		AddCncErr( x1, string.format("BTL ERROR: FAILED TO CONVERT GROOVE TO BIRDS MOUTH - SAVED AS GROOVE (nAngle7=%f, nAngle8=%f, groAngle=%f)", nAngle7, nAngle8, groAngle) )
		return false
	end


	nAngle8=PI-angleBeg
	nAngle7=nAngle8-PI2

	-- Ok bird's mouth and bottom beg calculated
	local nBtlSide, bMirrorY
	local nGroLen, nAngle, dx, dy
	

	dx=x2-x1
	dy=y2-y1
	nGroLen=math.sqrt(dx*dx+dy*dy)*math.cos(groAngleLen)		-- ON GROOVE BOTTOM
	nAngle=math.atan2(dyDir, dxDir)
	if nBegEnd==4 then
		nAngle=PI-nAngle
	end
	
	-------------------------------------
	-- Adjust to keep inside the plank. dyDir is always positive
	local xoff, yoff, zoff
	
	if yBot<0 and dyDir>0.001 then
		yoff=-yBot
		yBot=0

		xoff=dxDir/dyDir*yoff
		xBot=xBot+xoff

		zoff=dzDir/dyDir*yoff
		zBot=zBot-zoff

		nGroLen=nGroLen-math.sqrt(xoff*xoff+yoff*yoff+zoff*zoff)
	end

	faceDy=gnCurrWidth
	if groFace==2 or groFace==4 then
		faceDy=gnProfHeight
	end
	
	yoff=yBot+nGroLen*dyDir-faceDy
	if yoff>0 then
		xoff=dxDir/dyDir*yoff
		zoff=dzDir/dyDir*yoff
		nGroLen=nGroLen-math.sqrt(xoff*xoff+yoff*yoff+zoff*zoff)
	end
	-- Adjust to keep inside the plank.
	-------------------------------------

	if nAngle<PI/180 or nAngle>PI-PI/180 then
		return false
	end

	nBtlSide,bMirrorY=BtlGetSide14(groFace)
	x=BtlGetXc(xBot)
	y=yBot
	yBot2=nGroLen*dyDir		-- Actually len on surface

	--ac_msgbox(string.format("x=%f, y=%f, zBot=%f, yBot2=%f, bMirrorY=%s, nGroLen=%f", x, y, zBot, yBot2, tostring(bMirrorY), nGroLen))
	z=-dzDir
	if groFace==3 or groFace==4 then
		-- Swap beg/end points
		x=BtlGetXc(xBot+nGroLen*dxDir)
		y=yBot+nGroLen*dyDir
		zBot=zBot-nGroLen*dzDir

		nAngle=PI-nAngle
		z=-z
	end

	if bMirrorY then
		y=BtlMirrorYc(y, groFace)
	end
	--AddCncErr( x1, string.format("dzDir=%f z=%f, bMirrorY=%s)", dzDir, z, tostring(bMirrorY)) )


	--ac_msgbox( string.format("2: x1=%f, y1=%f, x2=%f, y2=%f, groDepth=%f, groWidth=%f, groAngle=%f, groAngleLen=%f", x1, y1, x2, y2, groDepth, groWidth, groAngle, groAngleLen) )
	s = string.format(	"PROCESSKEY:  %d-020-%d        BIRDS MOUTH\n" ..
						"PROCESSPARAMETERS: P01:%08.0f P02:%08.0f P05:00000000 P06:%08.0f P07:%08.0f P08:%08.0f P09:00000000 P10:00000000 P11:%08.0f P12:%08.0f P13:%08.0f P14:00000000 P15:00000000",
						nBegEnd,						-- X-020-1
						nBtlSide,						-- 3-020-X
						x * 10000.0,					-- P01
						y * 10000.0,					-- P02
						nAngle / PI * 1800,				-- P06
						nAngle7 / PI * 1800,			-- P07
						nAngle8/ PI * 1800,				-- P08
						zBot * 10000.0,					-- P11
						(zBot + nGroLen*z) * 10000.0,	-- P12
						yBot2 * 10000.0					-- P13
					  )

	BtlAddMc( x, s )

	if gbBtlMarkReinforce then
		-- Add also marking lines to the bottom side
		local x1, y1, y1_2
		local x2, y2, y2_2

		x1, y1, y1_2=BtlAddBirdMark( tblGroInfo.projside1, sPieceNum )
		x2, y2, y2_2=BtlAddBirdMark( tblGroInfo.projside2, sPieceNum )

		if x1 and x2 and math.abs(x2-x1)<0.001 then
			if y1>y1_2 then
				y1,y1_2=y1_2,y1
			end

			if y2>y2_2 then
				y2,y2_2=y2_2,y2
			end

			if y2>y1 then
				y1=y2
			elseif y1>y2 then
				y2=y1
			end

			if y2_2<y1_2 then
				y1_2=y2_2
			elseif y1_2<y2_2 then
				y2_2=y1_2
			end
		end

		if x1 then
			BtlAddMarking(sPieceNum, tblGroInfo.projside1.side, x1, y1, x1, y1_2, 2, 2, 0, 0, "", true, 1, true)
		end

		if x2 then
			BtlAddMarking(sPieceNum, tblGroInfo.projside2.side, x2, y2, x2, y2_2, 2, 2, 0, 0, "", true, 1, true)
		end
	end

	return true
end


function BtlAddBirdMark( tblProj, sPieceNum )
	--DumpTbl( tblProj )
	if tblProj.linebot.len<0.001 then
		--If not cutting whole plank: AddCncErr( 0, "WARNING: BtlAddBirdMark CANNOT ADD MARKER LINE1" )
		return
	end

	if not BtlIsIBeam() or not BtlHasReinforce() then
		return
	end
	
	local line2, mulDir2, x, y, dy, faceHeight

	-- Which one make up the birdsmouth (and other line positive towards the original surface
	line2=tblProj.lineref
	mulDir2=1
	x=tblProj.lineref.x1
	y=tblProj.lineref.y1
	if tblProj.lineref.len<tblProj.lineother.len then
		line2=tblProj.lineother
		mulDir2=-1
		x=tblProj.lineother.x2
		y=tblProj.lineother.y2
	end

	dy=(line2.y2-line2.y1)*mulDir2
	
	faceHeight=gnProfHeight
	if tblProj.side==1 or tblProj.side==3 then
		faceHeight=gnCurrWidth
	end
	
	if dy>0 then
		dy=0
		if y<dy then
			return
		end
	else
		dy=faceHeight
		if dy<y then
			return
		end
	end

	return x, y, dy
end



-- Adds groove as vcut at beg/end if possible
-- Returns: true=saved, false=not saved
function BtlAddGroAsVCut(sPieceNum, x1, y1, x2, y2, groDepth, groWidth, groAngle, groFace, groAngleLen)
	local d, dxDir, dyDir, dzDir, dxDown, dyDown, dzDown, dxBot, dyBot, dzBot, yBot2
	local x,y,z, nAngle7, nAngle8, nBegEnd, groLen, dx, dy, dz
	local nBtlSide,bMirrorY
	local vSideOrg, bSwapLR
	local tblGroInfo, tblGro, nBeg

	
	tblGro={}
	tblGro.guid	= gsCurrentLogGuid
	tblGro.x1	= x1
	tblGro.y1	= y1
	tblGro.x2	= x2
	tblGro.y2	= y2
	tblGro.depth	= groDepth
	tblGro.width	= groWidth
	tblGro.groAngleRad	= groAngle
	tblGro.face			= groFace
	tblGro.groTiltAngleRad	= groAngleLen
	tblGro.vCutToCurrent=1

	bSwapLR=false
	if groFace>4 then
		if math.abs(x2-x1)>math.abs(y1-y2) then
			if x1>x2 then
				bSwapLR=true
			end
		elseif y1>y2 then
			bSwapLR=true
		end
	elseif y1>y2 then
		bSwapLR=true
	end
	if bSwapLR then
		--AddCncErr( x1, "y1>y2" )
		af_request("mc_swapgroref", tblGro)
		x1	= tblGro.x1
		y1	= tblGro.y1
		x2	= tblGro.x2
		y2	= tblGro.y2
		groDepth	= tblGro.depth
		groAngle	= tblGro.groAngleRad
		groAngleLen	= tblGro.groTiltAngleRad
	end

	tblGroInfo = af_request("mc_getgroinfo", tblGro)

	if tblGroInfo==nil then
		return false
	end

	if tblGroInfo.vHun~=1 then
		return false
	end

	-- To ends try always, for other sides use only if double angle
	if groFace<5 and (math.abs(groAngle)<PI/180 or math.abs(groAngleLen)<PI/180) then
		return false
	end

	if tblGroInfo.vBeg~=0 then
		vSideOrg=tblGroInfo.vBeg
		nBtlSide=BtlGetSide14(tblGroInfo.vBeg)
		nBeg=2
	elseif tblGroInfo.vEnd~=0 then
		vSideOrg=tblGroInfo.vEnd
		nBtlSide=BtlGetSide14(tblGroInfo.vEnd)
		nBeg=1
	else
		return false
	end

	dummy,bMirrorY=BtlGetSide14(vSideOrg)

	bSwapLR=true
	if vSideOrg==4 or vSideOrg==3 then
		-- Need to swap upper&lower
		bSwapLR=false
	end
	
	x=BtlGetXc(tblGroInfo.vFaceX)
	y=tblGroInfo.vFaceY
	if bMirrorY then
		y=BtlMirrorYc(y, vSideOrg)
		bSwapLR=not bSwapLR
	end

	-- Hundegger uses the target face as origin when valley height is equal to thickness
	dx=gnCurrWidth
	if vSideOrg==1 or vSideOrg==3 then
		dx=gnProfHeight
	end
	
	--AddCncErr(x1, string.format("vSideOrg=%f vAngleL=%f vAngleR=%f vBevelL=%f vBevelR=%f", vSideOrg, tblGroInfo.vAngleL/PI*180, tblGroInfo.vAngleR/PI*180, tblGroInfo.vBevelL/PI*180, tblGroInfo.vBevelR/PI*180))

	-- Trial & error:
	tblGroInfo.vAngleL=PI-tblGroInfo.vAngleL
	tblGroInfo.vAngleR=PI-tblGroInfo.vAngleR

	if vSideOrg==1 then
		tblGroInfo.vBevelL=PI-tblGroInfo.vBevelL

	elseif vSideOrg==2 then
		tblGroInfo.vBevelL=PI-tblGroInfo.vBevelL
	
	elseif vSideOrg==3 then
		bSwapLR=not bSwapLR
		tblGroInfo.vBevelL=PI-tblGroInfo.vBevelL
	elseif vSideOrg==4 then
		bSwapLR=not bSwapLR
		tblGroInfo.vBevelL=PI-tblGroInfo.vBevelL
	else
		AddCncErr(x1, string.format("WARNING: BtlAddGroAsVCut, unsupported vSideOrg=%f SAVED AS NORMAL GROVE", vSideOrg))
		return false
	end
	
	if bSwapLR then
		tblGroInfo.vAngleR, tblGroInfo.vBevelR, tblGroInfo.vAngleL, tblGroInfo.vBevelL = tblGroInfo.vAngleL, tblGroInfo.vBevelL, tblGroInfo.vAngleR, tblGroInfo.vBevelR
	end

	-- 000101 0103 01     3000     565       0     100    1350     300    1000     600       0       0 000                           
	--										(Valley height)
	
	s = string.format(	"PROCESSKEY:  %d-011-%d        DOUBLE CUT\n" ..
						"PROCESSPARAMETERS: P01:%08.0f P02:%08.0f P05:00000000 P06:%08.0f P07:%08.0f P08:%08.0f P09:%08.0f",
						nBeg,							-- X-011-1
						nBtlSide,						-- 1-011-X
						x * 10000.0,					-- P01
						y * 10000.0,					-- P02
						tblGroInfo.vAngleL/PI*1800,		-- P06
						tblGroInfo.vBevelL/PI*1800,		-- P07
						tblGroInfo.vAngleR/PI*1800,		-- P08
						tblGroInfo.vBevelR/PI*1800		-- P09
					  )

	BtlAddMc( x1, s )

	--BvnAddLine( x, string.format( "%s 0103 %02d %8.0f %7.0f       0 %7.0f %7.0f %7.0f %7.0f %7.0f       0       0 000                           ",
								  --sPieceNum, nBtlSide, 10000*x, 10000*y, 10000*dx, tblGroInfo.vAngleR/PI*1800, tblGroInfo.vBevelR/PI*1800, tblGroInfo.vAngleL/PI*1800, tblGroInfo.vBevelL/PI*1800 ) )
--
	return true
end


-- Adds groove as saw cut if it is a narrow one
-- Returns: true=saved, false=not saved
function BtlAddGroAsSawCut(sPieceNum, x1, y1, x2, y2, groDepth, groWidth, groAngle, groFace, groAngleLen)
	if groWidth>0.0099 or groFace>=5 or groAngleLen>EPS then
		return false
	end

	local nBtlSide,bMirrorY, len, dx, dy, nAngle, s

	x1, y1, x2, y2, groDepth, groWidth, groAngle, groAngleLen = BtlGroCalcMid(x1, y1, x2, y2, groDepth, groWidth, groAngle, groAngleLen)

	nBtlSide,bMirrorY=BtlGetSide14(groFace)
	dx=x2-x1
	dy=y2-y1
	len=math.sqrt(dx*dx+dy*dy)
--ac_environment("tolog", string.format("dx=%f, dy=%f, x1=%f, y1=%f, x2=%f, y2=%f", dx, dy, x1, y1, x2, y2))

	if bMirrorY then
		y1=BtlMirrorYc(y1, groFace)
		dy=-dy
		groAngle=-groAngle
		groAngleLen=-groAngleLen		-- Not supported now
	end
	nAngle=math.atan2( dy, dx )
	nAngle=PI-nAngle
	if nAngle>PI then
		nAngle=-2*PI+nAngle
	elseif nAngle<-PI then
		nAngle=2*PI+nAngle
	end

	x1=BtlGetXc(x1)
	s = string.format(	"PROCESSKEY:  %d-013-%d        SAW CUT\n" ..
						"PROCESSPARAMETERS: P01:%08.0f P02:%08.0f P03:00000000 P06:%08.0f P07:%08.0f P08:%08.0f P11:%08.0f P12:%08.0f",
						0,								-- X-013-1
						nBtlSide,						-- 1-013-X
						x1 * 10000.0,					-- P01
						y1 * 10000.0,					-- P02
						nAngle / PI * 1800,				-- P06
						(PI2 - groAngle) / PI * 1800,			-- P07
						groAngleLen / PI * 1800,		-- P08 (anglelen)
						groDepth * 10000.0,				-- P11
						len * 10000.0					-- P12
						)

	BtlAddMc( x1, s )
	return true
end



function BtlDirToAngles(dirUpX, dirUpY, dirUpZ)
	local rotZ=0.0
	if math.abs(dirUpX)>EPS or math.abs(dirUpY)>EPS then
		rotZ=math.atan2(dirUpY, -dirUpX)
		if rotZ<0.0 then
			rotZ=PI*2+rotZ
		end
	end

	return rotZ, PI-math.asin(dirUpZ)
end


function BtlAddGroAsDrilling(sPieceNum, x1, y1, x2, y2, groDepth, groWidth, groAngle, groFace, groAngleLen)
	
	if groFace==5 or groFace==6 then
		local dx=x2-x1
		local dy=y2-y1
		local length=math.sqrt(dx*dx+dy*dy)
		local ux=dx/length
		local uy=dy/length
		local x=x1+ux*length/2-uy*groWidth/2
		local y=y1+uy*length/2+ux*groWidth/2
		local diameter=TernaryIf(length<groWidth, length, groWidth)
		return BtlAddDrill(sPieceNum, x, y, diameter, groDepth, groFace)
	end

	local tblGro={}
	tblGro.guid	= gsCurrentLogGuid
	tblGro.x1	= x1
	tblGro.y1	= y1
	tblGro.x2	= x2
	tblGro.y2	= y2
	tblGro.depth	= groDepth
	tblGro.width	= groWidth
	tblGro.groAngleRad	= groAngle
	tblGro.face			= groFace
	tblGro.groTiltAngleRad	= groAngleLen
	tblGroInfo = af_request("mc_getgroinfo", tblGro)

	local lenBot=tblGroInfo.lenBot
	local midPtBotX=x1+tblGroInfo.vecDownSurf.x*groDepth + tblGroInfo.vecLeftSurf.x*groWidth/2 + tblGroInfo.vecLenSurf.x*lenBot/2
	local midPtBotY=y1+tblGroInfo.vecDownSurf.y*groDepth + tblGroInfo.vecLeftSurf.y*groWidth/2 + tblGroInfo.vecLenSurf.y*lenBot/2
	local midPtBotZ=   tblGroInfo.vecDownSurf.z*groDepth + tblGroInfo.vecLeftSurf.z*groWidth/2 + tblGroInfo.vecLenSurf.z*lenBot/2

	local hasX, x, y, _z, _distToPlane=LinePlaneX(
		0, 0, 1, 0,
		midPtBotX, midPtBotY, midPtBotZ,
		midPtBotX-tblGroInfo.vecDownSurf.x,
		midPtBotY-tblGroInfo.vecDownSurf.y,
		midPtBotZ-tblGroInfo.vecDownSurf.z
	)

	if not hasX then
		AddCncErr(x1, string.format("ERROR: Drilling does not intersect plane"))
		return
	end

	-- In BTL the drilling distance is the perpendicular distance from the drilling middle end point to the surface
	local _hasX, _x, _y, _z, distToPlane=LinePlaneX(
		0, 0, 1, 0,
		midPtBotX, midPtBotY, midPtBotZ,
		midPtBotX, midPtBotY, midPtBotZ+1.0
	)

	local nBtlSide, mirrorY=BtlGetSide14(groFace)
	local vecUpX=-tblGroInfo.vecDownSurf.x
	local vecUpY=-tblGroInfo.vecDownSurf.y
	local vecUpZ=-tblGroInfo.vecDownSurf.z
	if mirrorY then
		y=BtlMirrorYc(y, groFace)
		vecUpY=-vecUpY
	end

	if gnBtlLogDir==EBtlDirEnd then
		vecUpX=-vecUpX
	end

	local rotZ, rotY=BtlDirToAngles(
		vecUpX,
		vecUpY,
		vecUpZ
	)

	local groDiameter=TernaryIf(lenBot<groWidth, lenBot, groWidth)

	s = string.format(	"PROCESSKEY:  4-040-%d        ANGLED DRILLING\n" ..
		"PROCESSPARAMETERS: P01:%08.0f P02:%08.0f P03:00000000 P06:%08.0f P07:%08.0f P11:%08.0f P12:%08.0f",
		nBtlSide,						-- 3-040-X
		BtlGetXc(x)*10000.0,			-- P01
		y*10000.0,		    			-- P02
		rotZ*180/PI*10.0,				-- P06
		rotY*180/PI*10.0,        		-- P07
		distToPlane*10000.0,        	-- P11
		groDiameter*10000.0         	-- P12
	)

	BtlAddMc( x, s )
end


-- Adds one groove in Logs coordinates to bvn-file. Adds notice if not possible.
-- groFace: 1=top, 2=front, 3=bottom, 4=back, 5=beg, 6=end
-- recCount is for internal use
-- Coordinates are always to whole log!
function BtlAddGro(sPieceNum, x1, y1, x2, y2, groDepth, groWidth, groAngle, groFace, groAngleLen, groType, recCount)
	local nBtlSide, bMirrorY
	local orgX1, orgY1, orgX2, orgY2, p4
	local nAngle, nGroLen, dx, dy, faceHeight

	faceHeight=gnProfHeight
	if groFace==1 or groFace==3 then
		faceHeight=gnCurrWidth
	end

	if x1<-1 or x1>gnCurrTotLen+1 or y1<-1 or y1>faceHeight+1 or x2<-1 or x2>gnCurrTotLen+1 or y2<-1 or y2>faceHeight+1 or groDepth>1 then
		AddCncErr( x1, string.format("WARNING: GROOVE WITH SUSPICIOUS BIG COORDINATES/DEPTH - WRITTEN INTO BTL FILE ANYWAY: x1=%.0f y1=%.0f x2=%.0f y2=%.0f depth=%.0f", x1*1000, y1*1000, x2*1000, y2*1000, groDepth*1000) )
	end

	-- ## Weinmann hack: If at the end, leave 1 mm uncut to avoid Weinmann doing the groove with the saw blade
	if gbBtlMoveGroFromEnd and groFace<5 and math.abs(x1-x2)<EPS and y1<0.001 and y2>faceHeight-0.001 then
		local s
		
		s=ac_objectget("iElemGroup")
		if string.match(s, "^bottom_force.*") or string.match(s, "^2ndbottom.*") or string.match(s, "^top_force.*") or string.match(s, "^2ndtop.*") then
			-- Straight full groove
			if x1-groWidth<EPS then
				groWidth=x1-0.001
				if gnBtlMinGroWidth>0 and groWidth<gnBtlMinGroWidth then
					x1=gnBtlMinGroWidth+0.001
					x2=x1
					groWidth=gnBtlMinGroWidth
				end
			elseif x1>gnCurrTotLen-EPS then
				groWidth=gnCurrTotLen-(x1-groWidth)-0.001
				x1=gnCurrTotLen-0.001
				x2=x1
				if gnBtlMinGroWidth>0 and groWidth<gnBtlMinGroWidth then
					groWidth=gnBtlMinGroWidth
				end

			end
		end
	end
	-- ## Weinmann  hack end

	--toLog( string.format( "GRO1, x1=%.3f y1=%.3f x2=%.3f y2=%.3f groDepth==%.3f groWidth=%.3f groAngle=%.3f groFace=%.3f groAngleLen=%.3f", x1, y1, x2, y2, groDepth, groWidth, groAngle, groFace, groAngleLen ) )

	orgX1=x1
	orgY1=y1
	orgX2=x2
	orgY2=y2

	-- Unit vector for the groove
	if gnBtlYoffset~=0 then
		-- Groove coordinates are always to whole log but we have half log raw material.
		if groFace==2 or groFace==4 or groFace==5 or groFace==6 then
			y1=y1-gnBtlYoffset
			y2=y2-gnBtlYoffset
		end
	end
	
	if groType==8 then
		BtlAddGroAsDrilling(sPieceNum, x1, y1, x2, y2, groDepth, groWidth, groAngle, groFace, groAngleLen)
		return
	end

	-- Try birds mouth
	if BtlAddGroAsBird(sPieceNum, x1, y1, x2, y2, groDepth, groWidth, groAngle, groFace, groAngleLen) then
		return
	end
	
	-- As V-cut at the end
	if BtlAddGroAsVCut(sPieceNum, x1, y1, x2, y2, groDepth, groWidth, groAngle, groFace, groAngleLen) then
		return
	end

	-- If it is a narrow groove
	if BtlAddGroAsSawCut(sPieceNum, x1, y1, x2, y2, groDepth, groWidth, groAngle, groFace, groAngleLen) then
		return
	end

	if groFace>4 then

--gnBtlPlateSide=EBtlMale
--ac_environment( "tolog", string.format("GRO %d %s", groFace, gsCurrentLogId))
		local ngroDepth, nBegEnd, pos

		
		-- Beg&End, adjust to midline, 017 takes groove middle point as refence
		x1, y1, x2, y2, groDepth, groWidth, groAngle, groAngleLen = BtlGroCalcMid(x1, y1, x2, y2, groDepth, groWidth, groAngle, groAngleLen)
		if groWidth<gnBtlMinGroWidth then
			groWidth=gnBtlMinGroWidth
		end

		if groFace==5 then
			pos=BtlGetXc(0)
		else
			pos=BtlGetXc(gnCurrTotLen)
		end

		dx=x2-x1
		dy=y2-y1
		nGroLen = math.sqrt( dx*dx + dy*dy )				-- T�m� on uran pituus pinnassa, pohjalla voi olla pienempi

		nBegEnd=4
		if groFace==6 then
			nBegEnd=3
		end

		if math.abs(x2-x1)>0.0001 then
			-- Non-vertical groove
			if math.abs(groAngle)>PI/180 then
				--ac_environment("tolog", string.format("x1=%f y1=%f x2=%f y2=%f\n", x1, y1, x2, y2) )
				if x1<0.001 and x2>gnCurrWidth-0.001 and math.abs(groAngleLen)<PI/180 then
					-- Special case: angled horizontal groove at the beg/end
					nBtlSide=BtlGetSide14(2)							-- Anchor to front side
					s = string.format(	"PROCESSKEY:  %d-017-%d        FRONT SLOT\n" ..
										"PROCESSPARAMETERS: P01:%08.0f P02:%08.0f P03:%08.0f P06:%08.0f P07:%08.0f P08:%08.0f P11:%08.0f P12:%08.0f P13:%08.0f",
										nBegEnd,						-- X-017-3
										nBtlSide,						-- 3-017-X
										pos * 10000.0,					-- P01
										(y1+y2) * 0.5 * 10000.0,		-- P02
										(x1+x2) * 0.5 * 10000.0,		-- P03
										(groAngle + PI2) / PI * 1800,	-- P06
										900,							-- (groAngleLen + PI2) / PI * 1800,-- P07
										900,							--nAngle / PI * 1800,				-- P08
										groDepth * 10000.0,				-- P11
										nGroLen * 10000.0,				-- P12
										groWidth * 10000.0				-- P13
										)

					BtlAddMc( pos, s )
					return
				end

				AddCncErr( pos, string.format("ERROR: ANGLED GROOVE NOT VERTICAL - ANGLE RESETED") )
				groAngle=0
			end

			if math.abs(groAngleLen)>PI/180 then
				AddCncErr( pos, string.format("ERROR: LENGTHWISE TILTED GROOVE NOT VERTICAL - ANGLE RESETED") )
				groAngleLen=0
			end
		end

		-- Depth at middle point
		groDepth		= groDepth + nGroLen * 0.5 * math.sin(groAngleLen)

		nBtlSide=BtlGetSide14(3)							-- Anchor to bottom side
		nBegEnd=4
		if groFace==6 then
			nBegEnd=3
		end

		nGroLen=nGroLen * math.cos(groAngleLen)				-- Len at bottom
		nAngle=-math.atan2(dy, dx)
		if nAngle<0 then
			nAngle=2*PI+nAngle
		end
		if nAngle>PI then
			-- Change from 180...360 deg to 0...180
			nAngle=nAngle-PI
		end
		if (nBtlSide==1 or nBtlSide==3) and math.abs(groAngle)<PI/180 and math.abs(groAngleLen)<PI/180 then
			-- Weinmann wants to anchor to btl side 2 (HACK!!!)
			-- Added nBtlSide==3 5/2014 after changing the feeding direction
			local	orgSide=nBtlSide

			nBtlSide=2
			dx=x1
			dy=x2
			x1=y1
			x2=y2
			if orgSide==1 then
				x1=gnProfHeight-x1
				x2=gnProfHeight-x2
			end
			y1=dx
			y2=dy
			nAngle=nAngle+PI2
			if nAngle>PI then
				-- Change from 180...360 deg to 0...180
				nAngle=nAngle-PI
			end
		end

		if math.abs(nAngle)<PI1800 then
			nAngle=0
		end

		s = string.format(	"PROCESSKEY:  %d-017-%d        FRONT SLOT\n" ..
							"PROCESSPARAMETERS: P01:%08.0f P02:%08.0f P03:%08.0f P06:%08.0f P07:%08.0f P08:%08.0f P11:%08.0f P12:%08.0f P13:%08.0f",
							nBegEnd,						-- X-017-3
							nBtlSide,						-- 3-017-X
							pos * 10000.0,					-- P01
							(x1+x2) * 0.5 * 10000.0,		-- P02
							(y1+y2) * 0.5 * 10000.0,		-- P03
							(-groAngle + PI2) / PI * 1800,	-- P06
							(-groAngleLen + PI2) / PI * 1800,-- P07
							nAngle / PI * 1800,				-- P08
							groDepth * 10000.0,				-- P11
							nGroLen * 10000.0,				-- P12
							groWidth * 10000.0				-- P13
						  )


		BtlAddMc( pos, s )
		return
	end

--	if (groFace==2 or groFace==4) and math.abs(groAngle)<EPS and groDepth+EPS>gnCurrWidth then
--		groDepth=0
--	end

	local tblGroInfo, tblGro, distFromSurf, tblGroSideIn, nGroSideIn
	
	-- Get groove info now for sides outside the plank
	tblGro={}
	tblGro.guid	= gsCurrentLogGuid
	tblGro.x1	= x1
	tblGro.y1	= y1
	tblGro.x2	= x2
	tblGro.y2	= y2
	tblGro.depth	= groDepth
	tblGro.width	= groWidth
	tblGro.groAngleRad	= groAngle
	tblGro.face			= groFace
	tblGro.groTiltAngleRad	= groAngleLen
	tblGro.vCutToCurrent=1
	tblGroInfo = af_request("mc_getgroinfo", tblGro)

	if groWidth<gnBtlMinGroWidth then
		-- Need to adjust the groove width keeping the center line
		dx=(gnBtlMinGroWidth-groWidth)*0.5
		groWidth=gnBtlMinGroWidth
		groDepth=groDepth + tblGroInfo.vecLeftSurf.z * dx

		x1=x1 - tblGroInfo.vecLeftSurf.x * dx
		y1=y1 - tblGroInfo.vecLeftSurf.y * dx

		x2=x2 - tblGroInfo.vecLeftSurf.x * dx
		y2=y2 - tblGroInfo.vecLeftSurf.y * dx

		orgX1=x1
		orgY1=y1
		orgX2=x2
		orgY2=y2

		-- Recalc
		tblGro.x1	= x1
		tblGro.y1	= y1
		tblGro.x2	= x2
		tblGro.y2	= y2
		tblGro.depth	= groDepth
		tblGro.width	= groWidth
		tblGro.groAngleRad	= groAngle
		tblGro.face			= groFace
		tblGro.groTiltAngleRad	= groAngleLen
		tblGro.vCutToCurrent=1
		tblGroInfo = af_request("mc_getgroinfo", tblGro)
	end
	
	-- Table ccw dir
	tblGroSideIn={}
	tblGroSideIn[1]=tblGroInfo.begIn
	tblGroSideIn[2]=tblGroInfo.refIn
	tblGroSideIn[3]=tblGroInfo.endIn
	tblGroSideIn[4]=tblGroInfo.leftIn
	nGroSideIn=1		-- Start from beg
	
	nBtlSide,bMirrorY=BtlGetSide14(groFace)
	x1=BtlGetXc(x1)
	x2=BtlGetXc(x2)
	
	if bMirrorY then
		y1=BtlMirrorYc(y1, groFace)
		y2=BtlMirrorYc(y2, groFace)
	end
	
	dx=x2-x1
	dy=y2-y1
	nGroLen=math.sqrt(dx*dx+dy*dy)
	nAngle=math.atan2(dy, dx)
	
	--toLog( string.format("nAngle=%f", nAngle))

	if nAngle<PI/180.0 or nAngle>PI-PI/180.0 then
		-- Limited to 1...179 deg

		if recCount==nil then
			-- First try swapping dir 180 deg
			recCount=0
			x1, y1, x2, y2, groDepth, groWidth, groAngle, groAngleLen = BtlGroRotateToNext(orgX1, orgY1, orgX2, orgY2, groDepth, groWidth, groAngle, groAngleLen, groFace)
			x1, y1, x2, y2, groDepth, groWidth, groAngle, groAngleLen = BtlGroRotateToNext(x1, y1, x2, y2, groDepth, groWidth, groAngle, groAngleLen, groFace)
			BtlAddGro(sPieceNum, x1, y1, x2, y2, groDepth, groWidth, groAngle, groFace, groAngleLen, groType, recCount)
			return
		else
			if recCount==4 then
				AddCncErr( x1, string.format("ERROR: BTL CNC WRITER COULD NOT SWAP GROOVE DIR - MAY CAUSE ERRORS LATER (2)") )
			else
				x1, y1, x2, y2, groDepth, groWidth, groAngle, groAngleLen = BtlGroRotateToNext(orgX1, orgY1, orgX2, orgY2, groDepth, groWidth, groAngle, groAngleLen, groFace)
				BtlAddGro(sPieceNum, x1, y1, x2, y2, groDepth, groWidth, groAngle, groFace, groAngleLen, groType, recCount+1)
				return
			end
		end
	end
	
	--DumpTbl(tblGroInfo.vecDownSurf)
	--AddCncErr( x1, string.format("distFromSurf=%f", distFromSurf) )

	if groFace==3 or groFace==4 then
		-- Need to swap the ref side
		x1, y1, x2, y2, groDepth, groWidth, groAngle, groAngleLen = BtlGroRotateToNext(orgX1, orgY1, orgX2, orgY2, groDepth, groWidth, groAngle, groAngleLen, groFace)
		x1, y1, x2, y2, groDepth, groWidth, groAngle, groAngleLen = BtlGroRotateToNext(x1, y1, x2, y2, groDepth, groWidth, groAngle, groAngleLen, groFace)
		x1, y1, x2, y2, groDepth, groWidth, groAngle, groAngleLen = BtlGroSwapDir(x1, y1, x2, y2, groDepth, groWidth, groAngle, groAngleLen)
		
		x1=BtlGetXc(x1)
		x2=BtlGetXc(x2)
		
		if bMirrorY then
			y1=BtlMirrorYc(y1, groFace)
			y2=BtlMirrorYc(y2, groFace)
		end
		nGroSideIn=3		-- Start from end
	end

	if math.abs(groAngle)>PI/1800 and math.abs(groAngleLen)>PI/1800 then
		AddCncErr( x1, string.format("ERROR: DOUBLE ANGLED GROOVE - NOT SUPPORTED AND SKIPPED ***") )
		return
	end
	
	local tblGro2, tblGroInfo2, tblGroInfo3

	tblGro2={}
	tblGro2.guid	= gsCurrentLogGuid
	tblGro2.x1	= x1
	tblGro2.y1	= y1
	tblGro2.x2	= x2
	tblGro2.y2	= y2
	tblGro2.depth	= groDepth
	tblGro2.width	= groWidth
	tblGro2.groAngleRad	= groAngle
	tblGro2.face			= groFace
	tblGro2.groTiltAngleRad	= groAngleLen
	tblGro2.vCutToCurrent=1
	tblGroInfo2 = af_request("mc_getgroinfo", tblGro2)

	distFromSurf=-groDepth*tblGroInfo2.vecDownSurf.z			-- Positive inside the plank

	tblGro2.groAngleRad	= 0
	tblGroInfo3 = af_request("mc_getgroinfo", tblGro2)
	x1=x1+groDepth*tblGroInfo3.vecDownSurf.x					-- Projected to surface (only lengthwise)
	y1=y1+groDepth*tblGroInfo3.vecDownSurf.y

	--toLog( string.format("2: x1=%f, y1=%f, x2=%f, y2=%f, groDepth=%f, groWidth=%f, groAngle=%f, groAngleLen=%f", x1, y1, x2, y2, groDepth, groWidth, groAngle, groAngleLen) )
	dx=x2-x1
	dy=y2-y1
	nGroLen=math.sqrt(dx*dx+dy*dy)			-- dx and dy unused after this

	-- # P4: which sides are open/not inside the plank
	p4=32		-- Change 9/2019: Mark it as open upwards: 0
	-- Begin
	if tblGroSideIn[nGroSideIn]==0 then
		p4=p4+4
	end
	nGroSideIn=(nGroSideIn%4)+1 
	-- Ref
	if tblGroSideIn[nGroSideIn]==0 then
		p4=p4+2
	end
	nGroSideIn=(nGroSideIn%4)+1 
	-- End
	if tblGroSideIn[nGroSideIn]==0 then
		p4=p4+8
	end
	nGroSideIn=(nGroSideIn%4)+1 
	-- Left
	if tblGroSideIn[nGroSideIn]==0 then
		p4=p4+1
	end

	local faceDy
	
	faceDy=gnProfHeight
	if groFace==1 or groFace==3 then
		faceDy=gnCurrWidth
	end

	if math.abs(y1)<0.0001 then
		y1=0
	end

	if math.abs(y1-faceDy)<0.0001 then
		y1=faceDy
	end

	--toLog( string.format("2: x1=%f, y1=%f, x2=%f, y2=%f, groDepth=%f, groWidth=%f, groAngle=%f, groAngleLen=%f", x1, y1, x2, y2, groDepth, groWidth, groAngle, groAngleLen) )
	if math.abs(tblGroInfo2.vecLenSurf.y)>0.010 then
		if tblGroInfo.begIn==0 then
			-- Move y1 to zero
			local y

			y=-y1
			if tblGroInfo2.vecLenSurf.y<0 then
				y=-y
			end
			x1=x1 + y * tblGroInfo2.vecLenSurf.x/tblGroInfo2.vecLenSurf.y
			distFromSurf=distFromSurf - y * tblGroInfo2.vecLenSurf.z/tblGroInfo2.vecLenSurf.y
			y1=0
		end

		if tblGroInfo.endIn==0 and y2>y1 and y2<faceDy then
			-- Make sure y2 is not less than surface, x2 UNUSED from here on
			x2=nil			-- Make it fail if used (nAngle calculated already)
			y2=faceDy
		end
	end

	if math.abs(nAngle)<PI1800 then
		nAngle=0
	end

	if math.abs(groAngleLen)<PI1800 then
		groAngleLen=0
	end

	s = string.format(	"PROCESSKEY:  3-030-%d        GROOVE\n" ..
						"PROCESSPARAMETERS: P01:%08.0f P02:%08.0f P03:00000000 P04:%08d P06:%08.0f P07:%08.0f P08:%08.0f P09:00000900 P10:00000000 P11:%08.0f P12:%08.0f P13:00000000 P14:%08.0f",
						nBtlSide,						-- 3-030-X
						x1 * 10000.0,					-- P01
						y1 * 10000.0,					-- P02
						10*p4,							-- P04
						nAngle / PI * 1800,				-- P06
						(groAngle + PI2) / PI * 1800,	-- P07
						groAngleLen / PI * 1800,		-- P08
						distFromSurf * 10000.0,			-- P11
						groWidth * 10000.0,				-- P12
						math.abs(y2-y1) * 10000.0				-- P14, was delta y actually (nGroLen * 10000.0)
					  )

	BtlAddMc( x1, s )
end


-- Calculates y-offset here!
-- depth 0 means drill through
function BtlAddDrill(sPieceNum, x1, y1, diameter, depth, face)
	local	nBtlSide, bMirrorX, bMirrorY, pos

	if face~=1 and face~=3 then
		y1=y1-gnBtlYoffset
	end
	
	if math.abs(depth)<0.0001 then
		if face==1 or face==3 then
			depth=gnProfHeight-gnBtlYoffset
		else
			depth=gnCurrWidth
		end
	end

	if face==5 or face==6 then
		-- To beg/end
		local nBegEnd

		nBtlSide,bMirrorX=BtlGetSide14(3)			-- Base on bottom side
		if bMirrorX then
			bMirrorX=false
		else
			bMirrorX=true
		end

		if face==5 then
			pos=BtlGetXc(0)
			nBegEnd=4
		else
			pos=BtlGetXc(gnCurrTotLen)
			nBegEnd=3
		end

		if bMirrorX then
			x1=gnCurrWidth-x1
		end

		s = string.format(	"PROCESSKEY:  %d-040-%d        DRILLING\n" ..
							"PROCESSPARAMETERS: P01:%08.0f P02:%08.0f P03:%08.0f P06:00000900 P07:00000900 P11:%08.0f P12:%08.0f",
							nBegEnd,						-- X-040-2
							nBtlSide,						-- 4-040-X
							pos * 10000.0,					-- P01
							x1 * 10000.0,					-- P02
							y1 * 10000.0,					-- P03
							depth * 10000.0,				-- P11
							diameter * 10000.0				-- P12
						  )

		BtlAddMc( pos, s )
		return
	end

	nBtlSide,bMirrorY=BtlGetSide14(face)
	x1=BtlGetXc(x1)

	if bMirrorY then
		y1=BtlMirrorYc(y1, face)
	end

	--PROCESSKEY:  4-040-4        DRILLING
	--PROCESSPARAMETERS: P01:00045000 P02:00001000 P03:00000000 P06:00000900 P07:00000900 P11:00001800 P12:00000200 
	
	s = string.format(	"PROCESSKEY:  4-040-%d        DRILLING\n" ..
						"PROCESSPARAMETERS: P01:%08.0f P02:%08.0f P03:00000000 P06:00000900 P07:00000900 P11:%08.0f P12:%08.0f",
						nBtlSide,						-- 4-040-X
						x1 * 10000.0,					-- P01
						y1 * 10000.0,					-- P02
						depth * 10000.0,				-- P11
						diameter * 10000.0				-- P12
					  )

	BtlAddMc( x1, s )
end


function BtlCheckLine(x1, y1, x2, y2, tblLine)
	local	x, y, len, dist, distStart

--ac_environment( "tolog", string.format("BtlCheckLine(%f, %f, %f, %f, tblLine=%f, %f, %f, %f)", x1, y1, x2, y2, tblLine.x1, tblLine.y1, tblLine.x2, tblLine.y2))
	x=tblLine.x2-tblLine.x1
	y=tblLine.y2-tblLine.y1
	len=math.sqrt(x*x+y*y)
	if len>0.0001 then
		x,y=ac_geo("linex", x1, y1, x2, y2, tblLine.x1, tblLine.y1, tblLine.x2, tblLine.y2)
		if x then
			dist, distStart,len=ac_geo("linedist", x1, y1, x2, y2, x, y)
			if distStart>-EPS and distStart<len+EPS then
				-- Intersection inside current line
				dist, distStart,len=ac_geo("linedist", tblLine.x1, tblLine.y1, tblLine.x2, tblLine.y2, x, y)
				if distStart>-EPS and distStart<len+EPS then
					dist, distStart,len=ac_geo("linedist", tblLine.x1, tblLine.y1, tblLine.x2, tblLine.y2, x1, y1)
					if dist<0 then
						-- Keep begin
						x2=x
						y2=y
					else
						-- Keep end
						x1=x
						y1=y
					end
				end
				
			end
		end
	end

	return x1,y1,x2,y2
end


-- Adds marking
-- textOff	Offset to RIGHT from the line (or in plank dir if line is point)
-- xPosText	1=left, 2=mid, 3=right
-- yPosText	1=bot, 2=mid, 3=top
-- bLine	true=make a line to the place, false=just text
-- bIsStop	true=is additional stop marking for reinforcement or begin/end, write only if supported side
function BtlAddMarking(sPieceNum, groFace, x1, y1, x2, y2, xPosText, yPosText, fontSize, textOff, strText, bLine, nTextParallel, bIsStop, bProcess)
	local nBtlSide, bMirrorY, dy, nAngle, bitMask, sProcess

	sProcess=""
	if bProcess~=nil and bProcess==false then
		sProcess="\nPROCESS: NO"
	end
	if groFace<1 or groFace>4 then
		AddCncErr( 0, string.format("WARNING - MARKING AT BAD SIDE (%d) SKIPPED", groFace) )
		return
	end

	if not bLine and strText=="" then
		return
	end

	if strText~=nil and strText~="" and math.abs(x2-x1)>0.001 and math.abs(y2-y1)<EPS and (groFace==2 or groFace==4) then
		-- Weinmann will print only text not in plank direction, turn it
		-- Hack 1/2016: Weinmann does not follow center definition
		-- Printer text size is fixed: height=15 mm average width of a character=10mm
		-- Also printer direction is fixed to plank direction
		-- In BTL viewer this will appear as 90 degrees text bottom at begin pos, Wupworks will turn it to plank dir
		x1=(x1+x2)/2
		x1=x1 - string.len(strText)*0.005
		x2=x1
		y1=0
		y2=gnProfHeight
		y1=0
		y2=gnProfHeight
		bLine=false			-- No meaningless line when turned
		yPosText=1
	end

	if gtblGroInfos and (strText==nil or strText=="") then
		-- 12/2015: Adjust to any groove not to go outside, causes problems to camera
		local i, v, side, x, y

		for i,v in ipairs(gtblGroInfos) do
			side=nil
			if v.tblGro.face<5 then
				if v.projside1.side==groFace then
					side=v.projside1
				elseif v.projside2.side==groFace then
					side=v.projside2
				end
			end
			if side~=nil then
				-- Check if intersecting with line

				-- First make sure lines are clockwise so that right side is outside of the plank
				if GetDist(side.lineother.x1, side.lineother.y1, side.linebot.x1, side.linebot.y1)<EPS or GetDist(side.lineother.x1, side.lineother.y1, side.linebot.x2, side.linebot.y2)<EPS then
					side.lineother.x1, side.lineother.y1, side.lineother.x2, side.lineother.y2=side.lineother.x2, side.lineother.y2, side.lineother.x1, side.lineother.y1
				end

				if GetDist(side.linebot.x2, side.linebot.y2, side.lineother.x2, side.lineother.y2)<EPS then
					side.linebot.x1, side.linebot.y1, side.linebot.x2, side.linebot.y2=side.linebot.x2, side.linebot.y2, side.linebot.x1, side.linebot.y1
				end

				if GetDist(side.lineref.x2, side.lineref.y2, side.linebot.x2, side.linebot.y2)<EPS then
					side.lineref.x1, side.lineref.y1, side.lineref.x2, side.lineref.y2=side.lineref.x2, side.lineref.y2, side.lineref.x1, side.lineref.y1
				end

				x1,y1,x2,y2=BtlCheckLine(x1, y1, x2, y2, side.lineother)
				x1,y1,x2,y2=BtlCheckLine(x1, y1, x2, y2, side.linebot)
				x1,y1,x2,y2=BtlCheckLine(x1, y1, x2, y2, side.lineref)
			end
		end
	end

	if bLine and (strText==nil or strText=="") and BtlIsIBeam() and math.abs(x2-x1)<0.001 and (groFace==2 or groFace==4) then
		-- Fix 1/2016: camera gets confused if markings are not centered
		if y1>y2 then
			y1,y2=y2,y2
		end
		dy=gnProfHeight-y2
		if y1>dy then
			dy=y1
		end
		if dy>gnProfHeight*0.5-0.001 then
			dy=gnProfHeight*0.5-0.001
		end
		y1=dy
		y2=gnProfHeight-dy
	end

	-- Second thought 12/2014: Let those come:
	--if bIsStop and groFace~=4 then
		-- Machine cannot print to these sides
	--	return
	--end

	nBtlSide,bMirrorY=BtlGetSide14(groFace)
	x1=BtlGetXc(x1)
	x2=BtlGetXc(x2)

	if bMirrorY then
		y1=BtlMirrorYc(y1, groFace)
		y2=BtlMirrorYc(y2, groFace)
	end

	if y1>y2+0.0001 then
		y1,y2=y2,y1
		x1,x2=x2,x2
	end

	-- Max height for the text
	if groFace==1 or groFace==3 then
		dy=gnCurrWidth
	else
		dy=gnProfHeight-gnBtlYoffset
	end
	
	fontSize=fontSize/100	-- From cm to meter
	if fontSize>dy*0.8 then
		fontSize=dy*0.8			-- Machine will determine the height
	end
	
	-- Build bits
	bitMask=1
	if bLine then
		bitMask=0
	end
	if strText~="" then
		if yPosText==1 then
			-- bottom
			bitMask=bitMask+2
		elseif yPosText==3 then
			-- Top
			bitMask=bitMask+8
		else
			-- Mid
			bitMask=bitMask+4
		end

		if xPosText==1 then
			-- left
			bitMask=bitMask+16
		elseif xPosText==3 then
			-- right
			bitMask=bitMask+64
		else
			-- Mid
			bitMask=bitMask+32
		end

		bitMask=bitMask+128
	end

	nAngle=math.atan2(y2-y1,x2-x1)/PI*180.0		-- In degrees
	
	if nAngle>179 and nAngle<181 then
		-- In plank dir x2<x1
		y1,y2=y2,y1
		x1,x2=x2,x1
		nAngle=math.atan2(y2-y1,x2-x1)/PI*180.0
	end

	if nAngle<1.1 and nAngle>-1.1 then
		-- In plank dir x2>x1
		if bLine then
			s = string.format(	"PROCESSKEY:  4-060-%d        MARKING\n" ..
								"PROCESSPARAMETERS: P01:%08.0f P02:%08.0f P04:%08d P06:00000900 P07:00000900 P11:%08.0f P12:%08.0f P13:%08.0f%s",
								nBtlSide,						-- 4-040-X
								x1 * 10000.0,					-- P01
								y1 * 10000.0,					-- P02
								bitMask*10,						-- P04
								(x2-x1) * 10000.0,				-- P11
								10.0,							-- P12, 1mm
								fontSize * 10000.0,
								sProcess
							  )
			BtlAddMc( x1, s )
		end

		if strText=="" then
			return
		end
		
		-- Adjust params to have line 90 deg at middle
		y1=dy*0.5-0.0005
		y2=y1+0.001
		x1=(x1+x2)*0.5
		x2=x1
		nAngle=90
		--DOES NOT WORK: bitMask=bitMask+1		-- No line
		nTextParallel=0			-- Will be anyway
	end

	if nAngle>80 and nAngle<100 and nTextParallel==1 then
		-- Turn text and recalc bitmask
		bitMask=BitTest(bitMask,0)		-- Keep line on/off
		-- xPos and yPos swapped
		if xPosText==1 then
			bitMask=bitMask+2
		elseif xPosText==3 then
			bitMask=bitMask+8
		else
			bitMask=bitMask+4
		end

		if yPosText==3 then
			bitMask=bitMask+16
		elseif yPosText==1 then
			bitMask=bitMask+64
		else
			bitMask=bitMask+32
		end

		bitMask=bitMask+1024
	end

	-- Add text always with this
	s = string.format(	"PROCESSKEY:  4-060-%d        MARKING\n" ..
						"PROCESSPARAMETERS: P01:%08.0f P02:%08.0f P04:%08d P06:%08.0f P07:00000000 P11:00000000 P12:%08.0f P13:%08.0f",
						nBtlSide,						-- 4-040-X
						x1 * 10000.0,					-- P01
						y1 * 10000.0,					-- P02
						bitMask*10,						-- P04
						nAngle*10,						-- P06
						(y2-y1) * 10000.0,				-- P12
						fontSize * 10000.0
					  )

	if strText~="" then
		s=s .. string.format(" P15:\"%s\"", string.gsub(strText, "\"", ""))
	end
	s=s .. sProcess
	BtlAddMc( x1, s )
end


-- nAngleTopDeg, angle from top 0=straight cut
function BtlAddBegEndTenon( sPieceNum, nBtlSide, bDove, tenonLen, tenonWidth, tenonHeight, borderBot, 
							nAngleSideDeg, nAngleTopDeg, roundingRadius, angleDoveDeg )

	AddCncErr( 0, "ERROR: TENON NOT SUPPORTED - SKIPPED" )
end

function TernaryIf ( cond , T , F )
    if cond then return T else return F end
end

function BtlAddVCutUsingSawCuts(nBtlSide, nSide, isBeg, nPos, y, p06, p08)

	cutDepth = TernaryIf(nSide==1 or nSide==3, gnProfHeight, gnCurrWidth)
	cutLen = gnCurrTotLen -- Will extend outside plank but perhaps machine understands

	p06 = -p06
	if not isBeg then
		p06 = TernaryIf(p06 > 0, 180 - p06, -(180 + p06))
		p08 = TernaryIf(p08 > 0, 180 - p08, -(180 + p08))
	end

	leftOrientation = 4  -- Begin oriented
	rightOrientation = 3 -- End oriented
	if p08 > p06 then
		leftOrientation, rightOrientation=rightOrientation, leftOrientation
	end

	s = string.format(	"PROCESSKEY:  %d-013-%d        SAW CUT\n" ..
		"PROCESSPARAMETERS: P01:%08.0f P02:%08.0f P03:00000000 P06:%08.0f P07:%08.0f P08:%08.0f P11:%08.0f P12:%08.0f",
		leftOrientation,				-- X-013-1
		nBtlSide,						-- 1-013-X
		nPos * 10000.0,					-- P01
		y * 10000.0,					-- P02
		10*p06,		    				-- P06
		10*90.0,						-- P07
		0.0, 							-- P08
		cutDepth*10000.0,				-- P11
		cutLen*10000.0					-- P12
	)
	BtlAddMc( nPos, s )

	s = string.format(	"PROCESSKEY:  %d-013-%d        SAW CUT\n" ..
		"PROCESSPARAMETERS: P01:%08.0f P02:%08.0f P03:00000000 P06:%08.0f P07:%08.0f P08:%08.0f P11:%08.0f P12:%08.0f",
		rightOrientation,				-- X-013-1
		nBtlSide,						-- 1-013-X
		nPos * 10000.0,					-- P01
		y * 10000.0,					-- P02
		10*p08,		    				-- P06
		10*90.0,						-- P07
		0.0, 							-- P08
		cutDepth*10000.0,				-- P11
		cutLen*10000.0					-- P12
	)

	BtlAddMc( nPos, s )
end

-- In ArchiFrame, angle tilt comes before bevel tilting
function BtlAddBegEndVCut(	sPieceNum, isBeg, nSide, x, y, angleDegR, bevelDegR, angleDegL, bevelDegL )
	local nBtlSide, nPos, bMirrorY, height, b, endMul, nBeg, s, p06, p08

	nBtlSide,bMirrorY=BtlGetSide14(nSide)
	b=bMirrorY
	if isBeg then
		b=not b
	end
	if nSide==3 or nSide==4 then
		b=not b
	end

	if b then
		p06=bevelDegL
		p08=bevelDegR
	else
		--AF and BTL think the same way here: y=BtlMirrorYc(y, nSide)
		p06=bevelDegR
		p08=bevelDegL
	end

	-- Set p06 and p08
	if isBeg then
		nPos=x
		endMul=1
		nBeg=2
	else
		nPos=gnCurrTotLen-x
		endMul=-1
		nBeg=1
	end
	
	if math.abs(angleDegR-90)>0.1 or math.abs(angleDegL-90)>0.1 then
		AddCncErr( x, "WARNING: V-CUT, ONLY 90 DEG ANGLE SUPPORTED, ANGLE SAVED AS 90 DEG." )
	end

	if nSide==1 or nSide==3 then
		y=gnCurrWidth*0.5-endMul*y
	else
		y=gnProfHeight*0.5-endMul*y
	end

	nPos = BtlGetXc(nPos)
	if p06 <= 1.0 or p08 <= 1.0 then
		BtlAddVCutUsingSawCuts(nBtlSide, nSide, b, nPos, y, p06, p08)
		return
	end

	s = string.format(	"PROCESSKEY:  %d-011-%d        DOUBLE CUT\n" ..
						"PROCESSPARAMETERS: P01:%08.0f P02:%08.0f P05:00000000 P06:%08.0f P07:%08.0f P08:%08.0f P09:%08.0f",
						nBeg,							-- X-011-1
						nBtlSide,						-- 1-011-X
						nPos * 10000.0,					-- P01
						y * 10000.0,					-- P02
						10*p06,							-- P06
						10*angleDegR,					-- P07
						10*(180-p08),					-- P08
						10*angleDegL					-- P09
					  )

	BtlAddMc( nPos, s )

end


function BtlAddHiddenShoe( isBeg, sPieceNum, holeWidth, holeHeight, holeDepth, groDepth, groWidth, drillLowest, drillFromEnd, drillSize, drillSpacing, drillCount )
	AddCncErr(0, string.format("BTL: HIDDEN SHOE NOT SUPPORTED") )
end


-- Kun palkki menee kapuloiden l�pi
function BtlAddBalkMid(sPieceNum, midPos, width, depthTop, depthBot, depthSides)
	local xc

	xc=midPos + width * 0.5
	BtlAddGro(sPieceNum, xc, 0, xc, gnCurrWidth, depthTop, width, 0, 1, 0)			-- Top
	BtlAddGro(sPieceNum, xc, 0, xc, gnProfHeight, depthSides, width, 0, 2, 0)		-- Front
	BtlAddGro(sPieceNum, xc, 0, xc, gnCurrWidth, depthBot, width, 0, 3, 0)			-- Bottom
	BtlAddGro(sPieceNum, xc, 0, xc, gnProfHeight, depthSides, width, 0, 4, 0)		-- Back
end


function BtlAddSideJoint( sPieceNum, logFace, bDove, midPos, borderBot, tenonLen, tenonWidth, tenonHeight, sideGap, 
						  bottomGap, angleDove, roundingRadius )

	AddCncErr( midPos, "ERROR: SIDE JOINT NOT SUPPORTED - SKIPPED" )
end



-- Adds window groove
-- groStart			Start coordinate of the groove (ends to the opening)
-- groOtherSideOff	Value to add to previous to get to other side
function BtlAddBuckGro( sPieceNum, nBtlSide, groStart, groOtherSideOff, buckWidth, buckDepth, openingDepth )
	AddCncErr( 0, "ERROR: BUCK GRO NOT SUPPORTED - SKIPPED" )
end



-- logFace	1=top, 3=bottom
-- nDepth	Depth from that face
-- x1,x2	In bvn-coordinates
-- bUseCutter	true=add cutter machinings to both sides, false=nope, just sawing
function BtlAddOpening( sPieceNum, logFace, nDepth, x1, x2, bUseCutter )
	AddCncErr( 0, "ERROR: OPENING NOT SUPPORTED - SKIPPED" )
end




-- xStart	Start coord in plank coordinates
-- dWidth	Width
-- dDepthTop	A Distance from surface to the cross pt (pos=inside plank, neg=outside)
-- dYoffTop		B Distance from surface middle to the cross pt in surface y-coordinate direction
-- dAngleY2Deg	C angle at surface y2
-- dAngleY1Deg	D angle at surface y1
function BtlAddSaw( sPieceNum, logFace, xStart, dWidth, dDepthTop, dYoffTop, dAngleY2Deg, dAngleY1Deg )
	local nBtlSide, bMirrorY, x1Real, x2Real, temp
	local nLen, nArea, nSplinter, dzNow, dyFace, dyFace2, nSingleCut, yc, nP4, nAngleRad


	if logFace>4 then
		AddCncErr( xStart, string.format("BtlAddSaw, BAD FACE: %d. MACHINING SKIPPED", logFace) )
		return
	end

	nBtlSide,bMirrorY=BtlGetSide14(logFace)

	-- Miten osuu puuhun
	x1Real=BtlGetXc(xStart)
	if dWidth==0 then
		x2Real=BtlGetXc(gnCurrTotLen)
	else
		x2Real=BtlGetXc(xStart+dWidth)
	end
	
	if x1Real>x2Real then
		x1Real,x2Real = x2Real,x1Real
	end
	
	dyFace=gnProfHeight
	dzNow=gnCurrWidth
	if logFace==1 or logFace==3 then
		dyFace=gnCurrWidth
		dzNow=gnProfHeight
	end

	dyFace2=dyFace*0.5
	nSingleCut=0
	if dYoffTop<-dyFace2+0.001 then
		-- Single cut only
		dAngleY1Deg=0
		nSingleCut=2
	elseif dYoffTop>dyFace2-0.001 then
		dAngleY2Deg=0
		nSingleCut=1
	end

	-- Tarkistetaan x-koordinaatit
	yc=dYoffTop+dyFace2
	if bMirrorY then
		yc=dyFace-yc
		dAngleY1Deg,dAngleY2Deg = dAngleY2Deg,dAngleY1Deg
		if nSingleCut==1 then
			nSingleCut=2
		elseif nSingleCut==2 then
			nSingleCut=1
		end
	end

	nP4=0
	nLen=x2Real-x1Real
	if x1Real<0.001 and x2Real>gnCurrTotLen-0.001 then
		nLen=0		-- Kaikki
		nP4=0
	elseif x1Real<0.001 then
		nP4=3
		nLen=x2Real
	elseif x2Real>gnCurrTotLen-0.001 then
		nP4=5
		nLen=gnCurrTotLen-x1Real
	else
		nP4=1
	end

	if nSingleCut==0 then
		-- Valley or hip
		s = string.format(	"PROCESSKEY:  0-012-%d        LONGITUDINAL CUT\n" ..
							"PROCESSPARAMETERS: P01:%08.0f P02:%08.0f P04:%08d P07:%08.0f P09:%08.0f P11:%08.0f P12:%08.0f P13:00000900 P14:00000900 P15:00000900 P16:00000900",
							nBtlSide,						-- 4-010-X
							x1Real * 10000.0,				-- P01
							yc * 10000.0,					-- P02
							nP4 * 10,						-- P04
							dAngleY1Deg*10,					-- P07
							dAngleY2Deg*10,					-- P09
							dDepthTop * 10000,				-- P11
							nLen * 10000.0					-- P12
						  )
						  
		BtlAddMc( x1Real, s )

	else
		-- Need to calculate yc to the point where the cut hits the surface
		if nSingleCut==1 then
			nAngleRad=dAngleY1Deg
		else
			nAngleRad=-dAngleY2Deg
		end
		nAngleRad=nAngleRad*PI/180
		if math.abs(nAngleRad)<PI1800 then
			-- Need to place on another surface
			-- BtlAddSaw( sPieceNum, logFace, xStart, dWidth, dDepthTop, dYoffTop, dAngleY2Deg, dAngleY1Deg )
			if logFace==1 then
				-- Top to front
				BtlAddSawStraight(sPieceNum, 2, x1Real, nLen, nP4, gnProfHeight-dDepthTop)
			elseif logFace==3 then
				-- Bottom to front
				BtlAddSawStraight(sPieceNum, 2, x1Real, nLen, nP4, dDepthTop)
			elseif logFace==2 then
				-- Front to top
				BtlAddSawStraight(sPieceNum, 1, x1Real, nLen, nP4, dDepthTop)
			elseif logFace==4 then
				-- Back to top
				BtlAddSawStraight(sPieceNum, 1, x1Real, nLen, nP4, gnCurrWidth-dDepthTop)
			end
			return
		else
			yc=yc+dDepthTop/math.tan(nAngleRad)
		end
		
		s = string.format(	"PROCESSKEY:  4-010-%d        LONGITUDINAL CUT\n" ..
							"PROCESSPARAMETERS: P01:%08.0f P02:%08.0f P04:%08d P07:%08.0f P11:00000000 P12:%08.0f P13:00000900 P14:00000900",
							nBtlSide,						-- 4-010-X
							x1Real * 10000.0,				-- P01
							yc * 10000.0,					-- P02
							nP4 * 10,						-- P04
							nAngleRad/PI*1800.0,			-- P07
							nLen * 10000.0					-- P12
						  )
						  
		BtlAddMc( x1Real, s )
	end
end


function BtlAddSawStraight(sPieceNum, logFace, x1Real, nLen, nP4, yc)
	local nBtlSide, bMirrorY, s


	nBtlSide,bMirrorY=BtlGetSide14(logFace)
	if bMirrorY then
		yc=BtlMirrorYc(yc, logFace)
	end
	s = string.format(	"PROCESSKEY:  4-010-%d        LONGITUDINAL CUT\n" ..
						"PROCESSPARAMETERS: P01:%08.0f P02:%08.0f P04:%08d P07:00000900 P11:00000000 P12:%08.0f P13:00000900 P14:00000900",
						nBtlSide,						-- 4-010-X
						x1Real * 10000.0,				-- P01
						yc * 10000.0,					-- P02
						nP4 * 10,						-- P04
						nLen * 10000.0					-- P12
						)
						  
	BtlAddMc( x1Real, s )

end

-----------------------------------------------------------------------------
-- FRAME PLANK


-- Returns width,height
function BtlGetPlankSize()
	local	width,height
	
	width=ac_objectget("iWidth")
	if width==nil or width==0.0 then
		width=ac_objectget("A")
	end

	height=ac_objectget("iHeight")
	if height==nil or height==0.0 then
		height=ac_objectget("B")
	end

	return width,height
end




-- Gets frame plank basic parameters:
-- gsCurrentLogId			Use same global as ArchiLogs to ease showing error msg
-- gnCurrTotLen
-- gnCurrHeight
-- gnCurrWidth
-- gnOverlap				Always zero
function BtlGetPlankBasicParams(unidPlank)
	local	dx, dy, dz, cosTiltAngle, tiltAngle

	gsCurrentLogId=ac_objectget("#id")
	gsCurrentLogGuid=unidPlank

	-- Pituus t�ytyy laskea
	tiltAngle=ac_objectget("iTiltAngle")
	cosTiltAngle=math.cos(tiltAngle)
	if math.abs(cosTiltAngle)<0.005 then
		-- Vertical
		gnCurrTotLen=ac_objectget("zzyzx")
	else
		dx=ac_objectget("iEndX")-ac_objectget("iBegX")
		dy=ac_objectget("iEndY")-ac_objectget("iBegY")
		dz=math.tan(tiltAngle)*math.sqrt(dx*dx + dy*dy)
		gnCurrTotLen=math.sqrt(dx*dx+dy*dy+dz*dz)
	end

	gnCurrWidth,gnCurrHeight=BtlGetPlankSize()
	gnOverlap=0		-- ac_objectget("iMatOverlap")
	gnBtlYoffset=0
	if gnOverlap==nil then
		gnOverlap=0
	end

	gnProfHeight=gnCurrHeight+gnOverlap
	
	gnBtlYoffset=0			-- Used for half logs
end



function BtlHasReinforce()
	local i, n, nType
	
	n=ac_objectget("iMc" ,-1)
	for i=1,n do
		nType=NormalizeType(ac_objectget("iMc", i, 1))
		if nType==EMcFrReinforce then
			return true
		end
	end
	return false
end


function BtlIsIBeam()
	local	matId

	matId=ac_objectget("iMatId")
	if string.sub(matId, 1, 2)=="H " or string.sub(matId, 1, 3)=="HI " or string.sub(matId, 1, 3)=="HB " then
		return true
	end
	return false
end


function BtlMarkReinforcement( sPieceNum, groFace, xMid, yMid, dx, dy, xPosText, yPosText, fontSize, textOff, s )
	if not gbBtlMarkReinforce then
		return
	end

	local	xOff, bDone, x
	
	BtlAddMarking(sPieceNum, groFace, xMid, yMid-0.01, xMid, yMid+0.01, xPosText, yPosText, fontSize, textOff, s, false, 0, true)
	
	xOff=0
	bDone=false
	while not bDone do
		if xOff+0.001>dx then
			xOff=dx
			bDone=true
		end
		x=xMid-dx*0.5+xOff
		if math.abs(x)<0.001 then
			x=0.001
		end
		if math.abs(x-gnCurrTotLen)<0.001 then
			x=gnCurrTotLen-0.001
		end
		BtlAddMarking(sPieceNum, groFace, x, yMid-dy*0.5, x, yMid+dy*0.5, xPosText, yPosText, fontSize, textOff, "", true, 0, true)
		xOff=xOff+0.650
	end

	if false then
		-- "Adidas" stripes
		BtlAddMarking(sPieceNum, groFace, xMid-dx*0.5, yMid-dy*0.5, xMid+dx*0.5, yMid-dy*0.5, xPosText, yPosText, fontSize, textOff, "", true, 0, true, false)
		BtlAddMarking(sPieceNum, groFace, xMid-dx*0.5, yMid,        xMid+dx*0.5, yMid,        xPosText, yPosText, fontSize, textOff, "", true, 0, true, false)
		BtlAddMarking(sPieceNum, groFace, xMid-dx*0.5, yMid+dy*0.5, xMid+dx*0.5, yMid+dy*0.5, xPosText, yPosText, fontSize, textOff, "", true, 0, true, false)
	end
end


function BtlWritePlank(unidPlank, nSimilarCount, tblSimilarPos)
	local res, i

	BtlGetPlankBasicParams(unidPlank)

	gnBtlBestPrintSide=4			-- Back side

	-- BTL (viewer) seems to turn the piece itself
	if gbBtlCalcFeed then
		if gnCurrWidth-EPS>gnProfHeight then
			if gnBtlLogDir==EBtlDirBeg then
				gnBtlPlateSide=EBtlBackSide
				gnBtlBestPrintSide=3
			else
				gnBtlPlateSide=EBtlFrontSide
				gnBtlBestPrintSide=1
			end
		else
			if gnBtlLogDir==EBtlDirBeg then
				gnBtlPlateSide=EBtlMale
			else
				gnBtlPlateSide=EBtlFemale
			end
		end
	end

	-- 3/2015: Change feeding direction if there are marking only on unsupported side
	-- Machine is able to do grooves and markings only to the side which is pointing upwards (back side of AF plank with default feeding dir)
	gbAnyCnc=false
	gtblGros={}
	gtblMarkings={}
	for i=1,6 do
		gtblGros[i]=0
		gtblMarkings[i]=0
	end

	res=BtlWritePlankInt(unidPlank, nSimilarCount, tblSimilarPos)

	if gnBtlLogDir==EBtlDirBeg and gnBtlPlateSide==EBtlMale and gtblGros[4]==0 and gtblMarkings[4]==0 and (gtblGros[2]>0 or gtblMarkings[2]>0) then
		-- Change front side to be pointing upwards
		gnBtlPlateSide=EBtlFemale
		gnBtlBestPrintSide=2			-- Front side
		res=BtlWritePlankInt(unidPlank, nSimilarCount, tblSimilarPos)
		gnBtlPlateSide=EBtlMale
	end

	return res
end



function BtlMakeGroInfoTbl()
	local tblGroInfos, i, n, x1, y1, x2, y2, groDepth, groWidth, groAngle, groFace, groAngleLen

	tblGroInfos={}
	n=ac_objectget("iMc" ,-1)
	for i=1,n do
		nType=NormalizeType(ac_objectget("iMc", i, 1))

		if nType==EMcFrGroove then
			x1		=ac_objectget("iMc", i, 2)
			y1		=ac_objectget("iMc", i, 3)
			x2		=ac_objectget("iMc", i, 4)
			y2		=ac_objectget("iMc", i, 5)
			groDepth=ac_objectget("iMc", i, 6)
			groWidth=ac_objectget("iMc", i, 7)
			groAngle=ac_objectget("iMc", i, 8)*PI/180.0
			groFace	=ac_objectget("iMc", i, 9)
			groAngleLen=ac_objectget("iMc", i, 10)*PI/180.0

			-- Save groove info to be used to cut reinforcement markings
			local tblGro

			tblGro={}
			tblGro.guid	= gsCurrentLogGuid
			tblGro.x1	= x1
			tblGro.y1	= y1
			tblGro.x2	= x2
			tblGro.y2	= y2
			tblGro.depth	= groDepth
			tblGro.width	= groWidth
			tblGro.groAngleRad	= groAngle
			tblGro.face			= groFace
			tblGro.groTiltAngleRad	= groAngleLen

			tblGroInfos[#tblGroInfos+1]=af_request("mc_getgroinfo", tblGro)
			tblGroInfos[#tblGroInfos].tblGro=tblGro
		end
	end

	return tblGroInfos
end


-- Add IMP if it is impregnent
function BtlGetIdPostStr()
	local s, res

	res=""
--  s=ac_objectget("iElemGroup")
--	if string.match(s, "^bottom_.*") or string.match(s, "^2ndbottom_.*") or string.match(s, "^top_.*") or string.match(s, "^2ndtop_.*") then
--		res=res .. " S"
--	end

	s=ac_objectget("iMatId")
	if string.match(s, "IMP") then
		res=res .. " IMP"
	end

	return res
end


gtblBtlElemQuant=nil			-- BtlGetPlankPackage() uses, key=elem guid, value=elem_quant for the element

function BtlGetPlankPackage()
	local info, item

	info=af_request("plankinfo")
	if info.ownerelemguid==nil then
		return ""
	end

	item=gtblBtlElemQuant[info.ownerelemguid]
	if item==nil then
		-- Get quant
		local quant

		quant=af_request("elem_quantities", info.ownerelemguid, 0)
		item=""
		if quant and quant.tblelems[1].xmlutf8 then
			-- At the end of the definition there is <cncinfo cnc_nailgun=xxx"></cncinfo>
			-- Quick&dirty: no real parsing
			item=string.match(quant.tblelems[1].xmlutf8, " cnc_outputline=\"(.-)\"")
			if item==nil then
				item=""
			else
				item=ToBtl(item)
			end
		end

		gtblBtlElemQuant[info.ownerelemguid]=item
	end

	return item
end



gnBtlScaleUnit=1		-- 1:SCALEUNIT=1, 2:SCALEUNIT=2

-- Converts metric length to btl-length str (8 digits for now)
function BtlLen2Str(val)
	local s

	if gnBtlScaleUnit==2 then
		s=string.format("%08.0f", val*100000)
	elseif gnBtlScaleUnit==1 then
		s=string.format("%08.0f", val*10000)
	else
		error("Bad gnBtlScaleUnit")
	end
	if string.len(s)>8 then
		if gnWarnings==nil then
			gnWarnings=0
		end
		if gnWarnings<100 then
			toLog( string.format("ERROR: COORDINATE TOO FAR FROM ORIGIN (MAX IS 99999999, PLEASE SET USER ORIGIN AS ANCHOR POINT: %s", s) )
			gnWarnings=gnWarnings+1
		end
	end

	return s
end


-- Taken from main Btl-writer
-- Creates string containing plank's position and orientation
-- strName is either "TRANSFORMATION" or "REFERENCEPLANE"
-- Trashes given "#plankinfo" info-parameter
-- plateSide gnBtlPlateSide
-- Uses gPlankTranMat for transformations
-- Also applies gnOrigX,Y,Z
function BtlCreatePosStr(strName, info, plateSide)

	info.begc.x=info.begc.x-gnOrigX
	info.begc.y=info.begc.y-gnOrigY
	info.begc.z=info.begc.z-gnOrigZ

	-- BTL origin at lower left looking at begin
	if gnBtlLogDir~=EBtlDirBeg then
		toLog("ERROR: BAD PLANK FEEDING DIR OR ROTATION, POSITION INFORMATION INCORRECT")
	end

	if gPlankTranMat then
		-- Transform coordinate system
		info.begc.x, info.begc.y, info.begc.z=MatTransformPt( info.begc.x, info.begc.y, info.begc.z, gPlankTranMat )
		info.vecx.x, info.vecx.y, info.vecx.z=MatTransformVec( info.vecx.x, info.vecx.y, info.vecx.z, gPlankTranMat )
		info.vecy.x, info.vecy.y, info.vecy.z=MatTransformVec( info.vecy.x, info.vecy.y, info.vecy.z, gPlankTranMat )
		info.vecz.x, info.vecz.y, info.vecz.z=MatTransformVec( info.vecz.x, info.vecz.y, info.vecz.z, gPlankTranMat )

--toLog( "transformed to:" )
--toLog( string.format("info.begc.x=%f, info.begc.y=%f, info.begc.z=%f", info.begc.x, info.begc.y, info.begc.z) )
--toLog( string.format("info.vecx.x=%f, info.vecx.y=%f, info.vecx.z=%f", info.vecx.x, info.vecx.y, info.vecx.z) )
--toLog( string.format("info.vecy.x=%f, info.vecy.y=%f, info.vecy.z=%f", info.vecy.x, info.vecy.y, info.vecy.z) )
--toLog( string.format("info.vecz.x=%f, info.vecz.y=%f, info.vecz.z=%f", info.vecz.x, info.vecz.y, info.vecz.z) )
	end

	if plateSide==EBtlFemale then
		-- Easiest case, just offset origin by half width in the y direction
		info.begc.x=info.begc.x+info.vecy.x*info.width*0.5
		info.begc.y=info.begc.y+info.vecy.y*info.width*0.5
		info.begc.z=info.begc.z+info.vecy.z*info.width*0.5
	elseif plateSide==EBtlMale then
		-- A bit trickier, need to flip z vector 180 degrees aswell and adjust origin in both directions
		info.begc.x=info.begc.x-info.vecy.x*info.width*0.5+info.vecz.x*info.height
		info.begc.y=info.begc.y-info.vecy.y*info.width*0.5+info.vecz.y*info.height
		info.begc.z=info.begc.z-info.vecy.z*info.width*0.5+info.vecz.z*info.height
		info.vecz.x=-info.vecz.x
		info.vecz.y=-info.vecz.y
		info.vecz.z=-info.vecz.z
	elseif plateSide==EBtlFrontSide then
		-- Even more tricky, need to rotate z-vector negative 90 degrees, cannot just "flip" it as in previous case
		local zx,zy,zz=RotateSingle3D(
			info.vecz.x, info.vecz.y, info.vecz.z, 
			info.vecx.x, info.vecx.y, info.vecx.z, 
			-PI/2
		)
		info.vecz.x=zx
		info.vecz.y=zy
		info.vecz.z=zz

		info.begc.x=info.begc.x-info.vecz.x*info.width*0.5
		info.begc.y=info.begc.y-info.vecz.y*info.width*0.5
		info.begc.z=info.begc.z-info.vecz.z*info.width*0.5
	elseif plateSide==EBtlBackSide then
		-- As in previous case, but rotation positive 90 degrees.
		-- Even more tricky since we need to offset the origin by the "new" y-vector, 
		-- (meaning the vector perpendicular to the new z-vector and the x-vector)
		local zx,zy,zz=RotateSingle3D(
			info.vecz.x, info.vecz.y, info.vecz.z, 
			info.vecx.x, info.vecx.y, info.vecx.z, 
			PI/2
		)

		info.vecz.x=zx
		info.vecz.y=zy
		info.vecz.z=zz

		local yx, yy, yz=CalcCross3D(
			info.vecx.x, info.vecx.y, info.vecx.z, 
			info.vecz.x, info.vecz.y, info.vecz.z
		)

		info.begc.x=info.begc.x-info.vecz.x*info.width*0.5-yx*info.height
		info.begc.y=info.begc.y-info.vecz.y*info.width*0.5-yy*info.height
		info.begc.z=info.begc.z-info.vecz.z*info.width*0.5-yz*info.height
	else
		error( "BtlCreatePosStr: Unknown orientation" )
	end

	return string.format(	"%s: OX:%s OY:%s OZ:%s XX:%s XY:%s XZ:%s YX:%s YY:%s YZ:%s", 
							strName,
							BtlLen2Str(info.begc.x), BtlLen2Str(info.begc.y), BtlLen2Str(info.begc.z),
							BtlLen2Str(info.vecx.x), BtlLen2Str(info.vecx.y), BtlLen2Str(info.vecx.z),
							BtlLen2Str(info.vecz.x), BtlLen2Str(info.vecz.y), BtlLen2Str(info.vecz.z) )
end


-- Write ArchiFrame plank BTL-code
-- ac_objectopen() must have been called before calling this
-- Saves CNC to variable gsCncText
function BtlWritePlankInt(unidPlank, nSimilarCount, tblSimilarPos)
	local	s, n, i, nOther, x, nDepth, x1, x2, dx, dy, nWidth, sBin, y, z, sPart, sMat
	local	bBegJoint, bEndJoint, nLeftRight
	local	nBtlSide, bMirrorY
	local	nAngleSide, nStraightSide, nAngleTop, nStraightTop, bLine, sStorey

	local	nFirstStopMark=nil			-- Need to add stop mark to begin if there is not one already
	local	nLastStopMark=nil			-- Need to add stop mark to end if there is not one already
	local   y1Stop, y2Stop


	if gnBtlLogDir~=EBtlDirBeg then
		RaiseError( "BTL writing having plank\'s end as reference point unsupported now" )
	end


	gnCncCount=0
	gTblCnc=nil
	gsCncText=""
	gsCurrentLogId=ac_objectget("#id")

	-- kappalenro suoraan ID:st�, jos on pelkk�� numeroa
	s=ac_objectget("iUsageId")
	if string.find(gsCurrentLogId, "[^%d]")==nil and gbBvnForceUnid==false then
		-- Pelkk�� numeroa
		if gnBtlPieceNum==nil then
			-- H�t�varana, jos on muitakin kuin pelkki� numeerisia tunnuksia
			gnBtlPieceNum=100000
		end
		sPieceNum=string.format( "%06s", gsCurrentLogId )
		sPart=s
	else
		-- ID:ss� muutakin kuin numeroa
		if gnBtlPieceNum==nil then
			gnBtlPieceNum=1
		end
		if s~="" then
			sPart=string.format( "%s (%s)", gsCurrentLogId, s)
		else
			sPart=string.format( "%s", gsCurrentLogId)
		end
		sPieceNum=string.format( "%06d", gnBtlPieceNum )
		gnBtlPieceNum=gnBtlPieceNum+1
	end
	
	if gBtlForceId~=nil then
		sPart=gBtlForceId
	end

	-- Headers
	if gnBtlPlateSide==EBtlMale or gnBtlPlateSide==EBtlFemale then
		y=gnCurrWidth
		x=gnProfHeight
	else
		x=gnCurrWidth
		y=gnProfHeight
	end
	
	sStorey=""
-- Was used by Birkeland:
--	if gnCurrWidth<0.0181 then
--		sStorey="3"
--	elseif BtlHasReinforce() then
--		sStorey="2"
--	elseif BtlIsIBeam() then
--		sStorey="1"
--	end
	sMat="Solid-Wood"
	if BtlIsIBeam() then
		sMat="I-Beams"
	end

	local sPackage=BtlGetPlankPackage()

	s = string.format(	"[PART]\n" ..
						"SINGLEMEMBERNUMBER: %d\n" ..
						"ASSEMBLYNUMBER:     \"\"\n" ..
						"ORDERNUMBER:        %d\n" ..
						"DESIGNATION:        \"%s\"\n" ..
						"ANNOTATION:         \"%s\"\n" ..
						"STOREY:             \"%s\"\n" ..
						"GROUP:              \"%s\"\n" ..
						"STOREYTYPE:         WALL\n" ..
						"ELEMENTNUMBER:      \"\"\n" ..
						"LAYER:              0\n" ..
						"MODULENUMBER:       \"\"\n" ..
						"PACKAGE:            \"%s\"\n" ..
						"MATERIAL:           \"%s\"\n" ..
						"TIMBERGRADE:        \"\"\n" ..
						"QUALITYGRADE:       \"\"\n" ..
						"COUNT:              %d\n" ..
						"LENGTH:             %08.0f\n" ..
						"HEIGHT:             %08.0f\n" ..
						"WIDTH:              %08.0f\n" ..
						"PLANINGLENGTH:      00000000\n" ..
						"STARTOFFSET:        %08.0f\n" ..
						"ENDOFFSET:          %08.0f\n",
						--"UID:                %d\n" ,
						gnBtlPieceNum,
						gnBtlPieceNum,
						ToBtl("(" .. sPart .. BtlGetIdPostStr() .. ")"),
						unidPlank,				-- ANNOTATION
						sStorey,
						ToBtl(sPieceNum),
						sPackage,
						sMat,
						nSimilarCount,
						gnCurrTotLen*10000.0,
						x*10000.0,
						y*10000.0,
						gnBtlStartEndOffset*10000.0,
						gnBtlStartEndOffset*10000.0 )
						--gnUid )

	gsCncText=s

	if gbBtlWriteUid then
		-- UID and TRANSFORMATION
		s=""
		ac_objectclose()
		for i=1,nSimilarCount do
			ac_objectopen(tblSimilarPos[i].guid)
			s=s .. string.format("UID: %d\n%s\n", gnUid, BtlCreatePosStr("TRANSFORMATION", af_request("plankinfo"), gnBtlPlateSide))
			ac_objectclose()

			tblSimilarPos[i].btluid=gnUid
			gnUid=gnUid+1
		end
		gsCncText=gsCncText .. s	
		ac_objectopen(unidPlank)
	else
		gnUid=gnUid+nSimilarCount
	end

	-- 12/2015: To avoid reinforcement markings intersecting the grooves (outside the plank)
	gtblGroInfos=BtlMakeGroInfoTbl()


	-- Frame plank has all machinings in single table including beginning and ending shapes
	-- # Machinings
	local	nSide, sSide, nSortPos
	local   bBegCut, bEndCut

	bBegCut=false
	bEndCut=false
	n=ac_objectget("iMc" ,-1)
	for i=1,n do
		nType=NormalizeType(ac_objectget("iMc", i, 1))


		if nType==EMcFrAngledBegOld then
			gbAnyCnc=true
			bBegCut=true
			nAngleTop=ac_objectget("iMc", i, 2)*PI/180
			nAngleSide=ac_objectget("iMc", i, 3)*PI/180
			nStraightTop=ac_objectget("iMc", i, 4)
			nStraightSide=ac_objectget("iMc", i, 5)
			
			-- Konversio hirren tyyliin
			if nAngleSide<0 then
				nAngleSide=PI/2+nAngleSide
			else
				nAngleSide=-PI/2+nAngleSide
			end

			-- P��lt� vain konversio hundegger-tyyliin
			if nAngleTop<0 then
				nAngleTop=-PI/2-nAngleTop
			else
				nAngleTop=PI/2-nAngleTop
			end
			BtlAddBegAngledOld( sPieceNum, nAngleSide, nStraightSide, nAngleTop, nStraightTop )

		elseif nType==EMcFrAngledBeg or nType==EMcFrAngledEnd then
			local isBeg

			isBeg=(nType==EMcFrAngledBeg)

			nAngleTop=ac_objectget("iMc", i, 2)*PI/180
			nAngleSide=ac_objectget("iMc", i, 3)*PI/180		-- Bevel
			x=ac_objectget("iMc", i, 4)
			y=ac_objectget("iMc", i, 5)
			z=ac_objectget("iMc", i, 6)
			isBeg=BtlAddBegEndAngled( sPieceNum, nAngleTop, nAngleSide, x, y, z, isBeg, i )

			if isBeg then
				bBegCut=true
			else
				bEndCut=true
			end

			if math.abs(nAngleTop-90)>0.1 or math.abs(nAngleSide-90)>0.1 then
				gbAnyCnc=true
			end

		elseif nType==EMcFrAngledBegTenon or nType==EMcFrAngledEndTenon then
			--! iMc[mindex][2], uihelp_length1: tapin pituus
			--! iMc[mindex][3], uihelp_length2: reunus yl�
			--! iMc[mindex][4], uihelp_length3: reunus ala
			--! iMc[mindex][5], uihelp_length4: tappi: reunus sivut, lohari: tapin leveys
			--! iMc[mindex][6], uihelp_length5: py�ristyss�de
			--! iMc[mindex][7], uihelp_angle1: kulma p��lt�
			--! iMc[mindex][8], uihelp_angle2: kallistuskulma
			--! iMc[mindex][9], uihelp_str3: Liitoksen tyyppi 1=Tappi, 2=Lohari
			--! iMc[mindex][10], uihelp_length6: Pohjav�lys
			--! iMc[mindex][11], uihelp_length7: Sivuv�lys
			--! iMc[mindex][12], uihelp_angle3: (Lohenpyrst�n) tapin kulma laajenus alhaalta yl�s
			
			gbAnyCnc=true
			bDove=false
			if ac_objectget("iMc", i, 9)==2 then
				bDove=true
			end

			tenonLen=ac_objectget("iMc", i, 2)
			tenonWidth=ac_objectget("iMc", i, 5)
			borderBot=ac_objectget("iMc", i, 4)
			tenonHeight=gnCurrHeight-ac_objectget("iMc", i, 3)-borderBot
			if not bDove then
				tenonWidth=gnCurrWidth-2*tenonWidth
			else
				-- If dovetail goes to top, set height to zero (empty=full dove male)
				if borderBot+tenonHeight+0.001>gnCurrHeight then
					tenonHeight=0
				end
			end

			nAngleTopDeg=ac_objectget("iMc", i, 7)
			nAngleSideDeg=ac_objectget("iMc", i, 8)
			
			-- P��lt� vain konversio hundegger-tyyliin
--			if nAngleTopDeg<0 then
--				nAngleTopDeg=-90-nAngleTopDeg
--			else
--				nAngleTopDeg=90-nAngleTopDeg
--			end

			-- 3=alapuoli
			nBtlSide=BtlGetLogBegBvnSide(3)
			if nType==EMcFrAngledEndTenon then
				nBtlSide=BtlGetLogEndBvnSide(3)
				nAngleSideDeg=-nAngleSideDeg
				nAngleTopDeg=-nAngleTopDeg
			end
			BtlAddBegEndTenon( sPieceNum, nBtlSide, bDove, tenonLen, tenonWidth, tenonHeight, borderBot, nAngleSideDeg, nAngleTopDeg, ac_objectget("iMc", i, 6), ac_objectget("iMc", i, 12) )

		elseif nType==EMcVCutBeg or nType==EMcVCutEnd then
			--double		dType;					// 1, EMcVCutBeg/EMcVCutEnd
			--double		dSideOneBased;			// 2, 1-4
			--double		dX;						// 3, distance from end to furthest point (usually zero)
			--double		dY;						// 4, Y-coordinate for the face from face mid line. pos to right in watching dir, neg to left
			--double		dAngleDegR;				// 5, angle at right side of the ref side
			--double		dBevelDegR;				// 6
			--double		dAngleDegL;				// 7, Left side
			--double		dBevelDegL;				// 8
			--
			--// GDL generation set by AF
			--double		dDirX;					// 9, mid line vector relative to the plank x 
			--double		dDirY;					// 10
			--double		dDirZ;					// 11
			--double		dCutAngleDegR;			// 12 Rotation for the cut, 0=no cut, 179=max
			--double		dCutAngleDegL;			// 13
			--
			local	isBeg, nSide, angleDegR, bevelDegR, angleDegL, bevelDegL


			if nType==EMcVCutBeg then
				--gbBegCut=true
				isBeg=true
			else
				--gbEndCut=true
				isBeg=false
			end

			nSide		=ac_objectget("iMc", i, 2)
			x			=ac_objectget("iMc", i, 3)
			y			=ac_objectget("iMc", i, 4)
			angleDegR	=ac_objectget("iMc", i, 5)
			bevelDegR	=ac_objectget("iMc", i, 6)
			angleDegL	=ac_objectget("iMc", i, 7)
			bevelDegL	=ac_objectget("iMc", i, 8)
			
			BtlAddBegEndVCut( sPieceNum, isBeg, nSide, x, y, angleDegR, bevelDegR, angleDegL, bevelDegL )

		elseif nType==EMcFrBegHiddenShoe or nType==EMcFrEndHiddenShoe then
			--! iMc[mindex][2], uihelp_length1: kolouksen leveys
			--! iMc[mindex][3], uihelp_length2: kolouksen korkeus
			--! iMc[mindex][4], uihelp_length3: kolouksen syvyys
			--! iMc[mindex][5], uihelp_length4: uran syvyys (ura on yht� korkea kuin kolous)
			--! iMc[mindex][6], uihelp_length5: uran leveys
			--! iMc[mindex][7], uihelp_length6: alin poraus yKeski
			--! iMc[mindex][8], uihelp_length7: porausten et�isyys p��st� (keskipiste)
			--! iMc[mindex][9], uihelp_length8: poran halkaisija
			--! iMc[mindex][10], uihelp_length9: porien v�listys pystysuunnassa
			--! iMc[mindex][11], uihelp_count1: porausten lukum��r�
			
			local	isBeg, holeWidth, holeHeight, holeDepth, groDepth, groWidth, drillLowest, drillFromEnd, drillSize, drillSpacing, drillCount

			gbAnyCnc=true
			isBeg=true
			if nType==EMcFrEndHiddenShoe then
				isBeg=false
			end
			holeWidth	=ac_objectget("iMc", i, 2)
			holeHeight	=ac_objectget("iMc", i, 3)
			holeDepth	=ac_objectget("iMc", i, 4)
			groDepth	=ac_objectget("iMc", i, 5)
			groWidth	=ac_objectget("iMc", i, 6)
			drillLowest	=ac_objectget("iMc", i, 7)
			drillFromEnd=ac_objectget("iMc", i, 8)
			drillSize	=ac_objectget("iMc", i, 9)
			drillSpacing=ac_objectget("iMc", i, 10)
			drillCount	=ac_objectget("iMc", i, 11)
			
			BtlAddHiddenShoe( isBeg, sPieceNum, holeWidth, holeHeight, holeDepth, groDepth, groWidth, drillLowest, drillFromEnd, drillSize, drillSpacing, drillCount )
			
		elseif nType==EMcFrAngledEndOld then
			bEndCut=true

			gbAnyCnc=true
			nAngleTop=ac_objectget("iMc", i, 2)*PI/180
			nAngleSide=ac_objectget("iMc", i, 3)*PI/180
			nStraightTop=ac_objectget("iMc", i, 4)
			nStraightSide=ac_objectget("iMc", i, 5)
			
			-- Konversio hirren tyyliin
			if nAngleSide<0 then
				nAngleSide=-PI/2-nAngleSide
			else
				nAngleSide=PI/2-nAngleSide
			end
			
			-- P��lt� puolen vaihto ja konversio hundegger-tyyliin
			nAngleTop=-nAngleTop
			if nAngleTop<0 then
				nAngleTop=-PI/2-nAngleTop
			else
				nAngleTop=PI/2-nAngleTop
			end
			--toLog( string.format("nAngleTop=%f", nAngleTop) )
			BtlAddEndAngledOld( sPieceNum, nAngleSide, nStraightSide, nAngleTop, nStraightTop )
		
		elseif nType==EMcFrOpening then
		
		elseif nType==EMcFrGroove then
			gbAnyCnc=true

			x1		=ac_objectget("iMc", i, 2)
			y1		=ac_objectget("iMc", i, 3)
			x2		=ac_objectget("iMc", i, 4)
			y2		=ac_objectget("iMc", i, 5)
			groDepth=ac_objectget("iMc", i, 6)
			groWidth=ac_objectget("iMc", i, 7)
			groAngle=ac_objectget("iMc", i, 8)*PI/180.0
			groFace	=ac_objectget("iMc", i, 9)
			groAngleLen=ac_objectget("iMc", i, 10)*PI/180.0
			groType  =ac_objectget("iMc", i, 11)

			gtblGros[groFace]=gtblGros[groFace]+1
			BtlAddGro(sPieceNum, x1, y1, x2, y2, groDepth, groWidth, groAngle, groFace, groAngleLen, groType)

		elseif nType==EMcFrDrill then
			gbAnyCnc=true

			x1		=ac_objectget("iMc", i, 2)
			y1		=ac_objectget("iMc", i, 3)
			groWidth=ac_objectget("iMc", i, 4)
			groDepth=ac_objectget("iMc", i, 5)
			groFace	=ac_objectget("iMc", i, 6)
			BtlAddDrill(sPieceNum, x1, y1, groWidth, groDepth, groFace)

		elseif nType==EMcFrMarking then
			gbAnyCnc=true

			x1		=ac_objectget("iMc", i, 2)
			y1		=ac_objectget("iMc", i, 3)
			x2		=ac_objectget("iMc", i, 4)
			y2		=ac_objectget("iMc", i, 5)
			xPosText=ac_objectget("iMc", i, 6)
			yPosText=ac_objectget("iMc", i, 7)
			fontSize=ac_objectget("iMc", i, 8)
			groFace	=ac_objectget("iMc", i, 9)
			textOff	=ac_objectget("iMc", i, 10)
			nParallel=BitTest(ac_objectget("iMc", i, 11), 1)
			bLine=true
			if BitTest(ac_objectget("iMc", i, 11), 2)==1 then
				bLine=false
			end

			gtblMarkings[groFace]=gtblMarkings[groFace]+1

			s=ac_objectget("iMcStr", i, 1)
			if math.abs(textOff)<0.001 or s=="" then
				-- No text offset
				BtlAddMarking(sPieceNum, groFace, x1, y1, x2, y2, xPosText, yPosText, fontSize, 0, s, bLine, nParallel)
				s=""
			elseif bLine then
				-- Only line
				BtlAddMarking(sPieceNum, groFace, x1, y1, x2, y2, xPosText, yPosText, fontSize, 0, "", bLine, nParallel)
			end
			
			if s~="" then
				-- Adjust the line with textOff and only text here
				dx=x2-x1
				dy=y2-y1
				z=math.sqrt(dx*dx+dy*dy)
				if z>0.001 then
					dx=dx/z
					dy=dy/z
					dx,dy=dy,-dx		-- To right
					x1=x1+dx*textOff
					y1=y1+dy*textOff
					x2=x2+dx*textOff
					y2=y2+dy*textOff
				end
				BtlAddMarking(sPieceNum, groFace, x1, y1, x2, y2, xPosText, yPosText, fontSize, 0, s, false, nParallel)
			end

		elseif nType==EMcFrReinforce then
			gbAnyCnc=true

			x1		=ac_objectget("iMc", i, 2)
			y1		=ac_objectget("iMc", i, 3)
			dx		=ac_objectget("iMc", i, 4)
			dy		=ac_objectget("iMc", i, 5)
			groFace	=ac_objectget("iMc", i, 7)

			xPosText=2
			yPosText=2
			if groFace==1 or groFace==3 then
				fontSize=gnCurrWidth
			else
				fontSize=gnProfHeight-gnBtlYoffset
			end
			fontSize=fontSize*50		-- 50% and to cm
			
			if dx<0.0005 then
				dx=gnCurrTotLen
				x1=gnCurrTotLen*0.5
			end

			textOff	=0
			s=ac_objectget("iMcStr", i, 1)
			if s=="" then
				s=string.format("%.0f x %.0f", dx*1000, dy*1000)
			end
			s=""		-- No text
			BtlMarkReinforcement( sPieceNum, groFace, x1, y1, dx, dy, xPosText, yPosText, fontSize, textOff, s )

			if ac_objectget("iMc", i, 8)~=0 then
				-- Both sides
				if groFace==1 then
					groFace=3
				elseif groFace==2 then
					groFace=4
				elseif groFace==3 then
					groFace=1
				elseif groFace==4 then
					groFace=2
				elseif groFace==5 then
					groFace=6
				elseif groFace==6 then
					groFace=5
				end
				BtlMarkReinforcement( sPieceNum, groFace, x1, y1, dx, dy, xPosText, yPosText, fontSize, textOff, s )
			end

			local xmin=x1-dx*0.5
			local xmax=x1+dx*0.5

			if nFirstStopMark==nil then
				nFirstStopMark=xmin
				y1Stop=y1-dy*0.5
				y2Stop=y1Stop+dy
			elseif xmin<nFirstStopMark then
				nFirstStopMark=xmin
				y1Stop=y1-dy*0.5
				y2Stop=y1Stop+dy
			end

			if nLastStopMark==nil then
				nLastStopMark=xmax
			elseif xmax>nLastStopMark then
				nLastStopMark=xmax
			end

		elseif nType==EMcFrNailGroup then
			if false then
				local col, row, cols, rows, anglex, angley

				gbAnyCnc=true
				x1		=ac_objectget("iMc", i, 2)
				y1		=ac_objectget("iMc", i, 3)
				cols	=ac_objectget("iMc", i, 4)
				rows	=ac_objectget("iMc", i, 5)
				anglex	=ac_objectget("iMc", i, 6)*PI/180
				angley	=ac_objectget("iMc", i, 7)*PI/180

				dx		=ac_objectget("iMc", i, 8)
				dy		=ac_objectget("iMc", i, 9)
				groFace	=ac_objectget("iMc", i, 11)

				if groFace~=gnBtlBestPrintSide then
					if groFace==2 and gnBtlBestPrintSide==4 then
						groFace=4
					elseif groFace==4 and gnBtlBestPrintSide==2 then
						groFace=2
					end
				end

				for col=1,cols do
					for row=1,rows do
						x=x1 + (col-1)*dx*math.cos(anglex) + (row-1)*dy*math.cos(angley)
						y=y1 + (col-1)*dx*math.sin(anglex) + (row-1)*dy*math.sin(angley)
						BtlAddMarking(sPieceNum, groFace, x, y-0.02, x, y+0.02, 2, 2, 0, 0, "", true, 0, false, false)
						BtlAddMarking(sPieceNum, groFace, x-0.02, y, x+0.02, y, 2, 2, 0, 0, "", true, 0, false, false)
					end
				end
			end
		elseif nType==EMcFrNailLine then
			-- NOP here
		elseif nType==EMcFrSaw then
			-- Lengthwise sawing
			gbAnyCnc=true
			logFace		=ac_objectget("iMc", i, 2)
			xStart		=ac_objectget("iMc", i, 3)		-- +begExtra
			dWidth		=ac_objectget("iMc", i, 4)
			dDepthTop	=ac_objectget("iMc", i, 5)
			dYoffTop	=ac_objectget("iMc", i, 6)
			dAngleY2Deg	=ac_objectget("iMc", i, 7)
			dAngleY1Deg	=ac_objectget("iMc", i, 8)
			BtlAddSaw( sPieceNum, logFace, xStart, dWidth, dDepthTop, dYoffTop, dAngleY2Deg, dAngleY1Deg )

		elseif nType==EMcFrTenonSide then
			--! ### 400: Tappiliitos tai lohari kylkeen
			--! iMc[mindex][2], uihelp_length1: keskipiste kapulan alusta
			--! iMc[mindex][3], uihelp_length2: korkeusasema kapulan alareunasta
			--! iMc[mindex][4], uihelp_length3: tapin pituus
			--! iMc[mindex][5], uihelp_length4: kolon leveys
			--! iMc[mindex][6], uihelp_length5: kolon korkeus
			--! iMc[mindex][7], uihelp_length6: Pohjav�lys
			--! iMc[mindex][8], uihelp_length7: Sivuv�lys
			--! iMc[mindex][9], uihelp_length8: py�ristyss�de
			--! iMc[mindex][10], uihelp_puoli: 1...4
			--! iMc[mindex][11], uihelp_str3: Liitoksen tyyppi 1=Tappi, 2=Lohari
			--! iMc[mindex][12], uihelp_angle1: (Lohenpyrst�n) tapin kulma laajenus alhaalta yl�s
			
			local logFace, str, bDove, midPos, borderBot, tenonLen, tenonWidth, tenonHeight, sideGap, bottomGap, angleDove, roundingR


			gbAnyCnc=true
			bDove=false
			if ac_objectget("iMc", i, 11)==2 then
				bDove=true
			end
			
			midPos		=ac_objectget("iMc", i, 2)
			borderBot	=ac_objectget("iMc", i, 3)
			tenonLen	=ac_objectget("iMc", i, 4)
			tenonWidth	=ac_objectget("iMc", i, 5)
			tenonHeight	=ac_objectget("iMc", i, 6)
			sideGap		=ac_objectget("iMc", i, 7)
			bottomGap	=ac_objectget("iMc", i, 8)
			roundingR	=ac_objectget("iMc", i, 9)
			logFace		=ac_objectget("iMc", i, 10)
			angleDove	=ac_objectget("iMc", i, 12)

			BtlAddSideJoint( sPieceNum, logFace, bDove, midPos, borderBot, tenonLen, tenonWidth, tenonHeight, sideGap, 
							 bottomGap, angleDove, roundingR )

		elseif nType==EMcFrBalkJoint then
			--! ### 401: Palkin kaulus
			--! iMc[mindex][2], uihelp_length1: keskipiste kapulan alusta
			--! iMc[mindex][3], uihelp_length2: kauluksen leveys
			--! iMc[mindex][4], uihelp_length3: kolous yl�
			--! iMc[mindex][5], uihelp_length4: kolous ala
			--! iMc[mindex][6], uihelp_length5: kolous sivut
			
			gbAnyCnc=true
			midPos		=ac_objectget("iMc", i, 2)
			width		=ac_objectget("iMc", i, 3)
			depthTop	=ac_objectget("iMc", i, 4)
			depthBot	=ac_objectget("iMc", i, 5)
			depthSides	=ac_objectget("iMc", i, 6)
			BtlAddBalkMid(sPieceNum, midPos, width, depthTop, depthBot, depthSides)

		elseif nType==EMcFrBalkShoe then
			-- NOP on purpose
		elseif nType~=0 then
			AddCncErr( ac_objectget("iMc", i, 2), string.format("UNSUPPORTED MACHINING %d", nType) )
		end
	end

	-- Reverted 12/2014 back to have these only if markings
	if BtlIsIBeam() and false then
		-- We want to have markings
		if y1Stop==nil then
			y1Stop=0
			y2Stop=gnCurrHeight
		end

		if nFirstStopMark==nil then
			nFirstStopMark=gnCurrTotLen
		end

		if nLastStopMark==nil then
			nLastStopMark=0
		end
	end

	if gbBtlMarkReinforce then
		if nFirstStopMark~=nil then
			-- Stop mark if any reinforcements and not at begin
			if nFirstStopMark>0.002 then
				BtlAddMarking(sPieceNum, 2, 0.001, y1Stop, 0.001, y2Stop, 0, 0, 0, 0, "", true, 0, true)
				BtlAddMarking(sPieceNum, 4, 0.001, y1Stop, 0.001, y2Stop, 0, 0, 0, 0, "", true, 0, true)
			end
		end
	
		if nLastStopMark~=nil then
			-- Stop mark if any reinforcements and not at end
			if nLastStopMark<gnCurrTotLen-0.002 then
				BtlAddMarking(sPieceNum, 2, gnCurrTotLen-0.001, y1Stop, gnCurrTotLen-0.001, y2Stop, 0, 0, 0, 0, "", true, 0, true)
				BtlAddMarking(sPieceNum, 4, gnCurrTotLen-0.001, y1Stop, gnCurrTotLen-0.001, y2Stop, 0, 0, 0, 0, "", true, 0, true)
			end
		end
	end
	
	-----------------------------------
	-- Straight beg & end
	-----------------------------------
	
	if gnBtlLogDir==EBtlDirEnd then
		-- Swap beg & end
		i=bBegCut
		bBegCut=bEndCut
		bEndCut=i
	end

	if bBegCut==false then
		s =	"PROCESSKEY:  2-010-2        CUT\n" ..
			"PROCESSPARAMETERS: P01:00000000 P02:00000000 P03:00000000 P06:00000900 P07:00000900"
		BtlAddMc( -1, s )
	end
	
	if bEndCut==false then
		s = string.format(	"PROCESSKEY:  1-010-2        CUT\n" ..
							"PROCESSPARAMETERS: P01:%08.0f P02:00000000 P03:00000000 P06:00000900 P07:00000900",
							gnCurrTotLen*10000.0 )

		BtlAddMc( gnCurrTotLen+1, s )
	end

	-----------------------------------
	-- Others
	-----------------------------------

	
	if gsBtlPartId~="" then
		local sMark, xMid, yTop, x1, width

--		s=ac_objectget("iUsageId")
--		if s~="" and s~="ELEM" then
--			sMark=string.format( "%s (%s)", gsCurrentLogId, s)
--		else
--			sMark=string.format( "%s", gsCurrentLogId)
--		end
--		sMark="(" .. sMark .. BtlGetIdPostStr() .. ")"
		sMark=gsBtlPartId
		sMark=ac_environment ("strreplace", sMark, "#fullid#", gsCurrentLogId)
		sMark=ac_environment ("strreplace", sMark, "#projnum#", ac_environment("parsetext", "<PROJECTNUMBER>"))
		sMark=ac_environment ("strreplace", sMark, "#projid#", ac_environment("parsetext", "<PROJECT_ID>"))
		sMark=ac_environment ("strreplace", sMark, "#length#", ToBtl(ac_environment("ntos", gnCurrTotLen, "length", "dim")))
		sMark=ac_environment ("strreplace", sMark, "#lengthmm#", string.format("%0.0f", gnCurrTotLen*1000))

		xMid=gnCurrTotLen*0.5
		if gnBtlPartIdFromEnd>=0 then
			if xMid<gnCurrTotLen-gnBtlPartIdFromEnd then
				xMid=gnCurrTotLen-gnBtlPartIdFromEnd
			end
		else
			if xMid>-gnBtlPartIdFromEnd then
				xMid=-gnBtlPartIdFromEnd
			end
		end

		yTop=gnCurrHeight
		if BtlIsIBeam() or gnCurrHeight>gnBtlPartIdTopFromBot then
			yTop=gnBtlPartIdTopFromBot		-- For I-Beams to the lower part (also all)
			if yTop>gnCurrHeight then
				yTop=gnCurrHeight
			end
		end

		-- Adjust so that does not intersect with grooves and markings
		width=string.len(sMark)*0.010		-- 10 mm per character
		width=width+0.040
		x1=xMid-width*0.5
		x1=af_request("mc_findtextpos", gnBtlBestPrintSide, x1, width)

		xMid=x1+width*0.5
		BtlAddMarking(sPieceNum, gnBtlBestPrintSide, xMid, 0, xMid, yTop, 2, 2, 0, 0, sMark, false, 0)
	end

	-- From table to text
	if gTblCnc~=nil then
		-- Sort the table and create full text
		table.sort(gTblCnc, function (n1, n2)
			if math.abs(n1.pos-n2.pos)>EPS then
				return n1.pos < n2.pos		-- compare the sort key
			end
			
			return n1.count < n2.count		-- Keep the order if at same pos
		end)

		local tblBeg, tblMid, tblEnd, cncindex

		tblBeg=BtlProfPolyToEdges("iMatProfileXzBeg", gnCurrHeight)
		tblMid=BtlProfPolyToEdges("iMatProfileXzMid", gnCurrHeight)
		tblEnd=BtlProfPolyToEdges("iMatProfileXzEnd", gnCurrHeight)

		if tblEnd then
			BtlProfPolyToEnd(tblEnd, gnCurrTotLen)
		end

		cncindex=1
		if tblBeg~=nil then
			-- Profile at begin, find position
			for i,v in ipairs(gTblCnc) do
				if v.pos>0 then
					cncindex=i
					break
				end
			end

			cncindex=cncindex+BtlInsertProfTbl(tblBeg, 0, false, gnCurrHeight, gTblCnc, cncindex)
		end

		if tblMid~=nil then
			-- Profile at mid
			local	x1, x2

			x1=0
			if tblBeg then
				x1=tblBeg.box.x2
			end

			x2=gnCurrTotLen
			if tblEnd then
				x2=tblEnd.box.x1
			end

			while cncindex<=#gTblCnc do
				v=gTblCnc[cncindex]
				if v.pos>x1 then
					break
				end
				cncindex=cncindex+1
			end

			cncindex=cncindex+BtlInsertProfTblMid(tblMid, gnCurrHeight, gTblCnc, cncindex, x1, x2)
		end

		if tblEnd~=nil then
			-- Profile at end
			while cncindex<=#gTblCnc do
				v=gTblCnc[cncindex]
				if v.pos>gnCurrTotLen-tblEnd.box.x2 then
					break
				end
				cncindex=cncindex+1
			end

			cncindex=cncindex+BtlInsertProfTbl(tblEnd, 0, true, gnCurrHeight, gTblCnc, cncindex)
		end

		for i,v in ipairs(gTblCnc) do
			gsCncText=gsCncText .. v.text .. string.format("\nPROCESSIDENT: %d\n", i)
		end
	end

	return 1
end


-- ### Lengthwise profile BEG

-- Converts object's table into lines and arcs. Contour goes ccw/right hand side outside
-- Returns: nil=no definition, otherwise structure having fields:
-- box, structure
--	x1,x2,y1,y2	Polygon bound box (x1,y1 always 0)
--	hasbot		Is bottom other than a line covering x1 -> x2
--	hastop		Is top other than a line covering x1 -> x2
-- edges, 1-based table having fields:
--	x1,y1	Begin pt
--	x2,y2	End point
--	isarc	true=is arc and following set, nil=line
--	midx,midy	Arc's center point
--	anglebegrad	Angle at starting point
--	anglelenrad	Angle length
function BtlProfPolyToEdges(parName, faceHeight)
	local	n, i, v, prevx, prevy, midx, midy, x2, y2, status, dest
	local	tbl, tblBox, tblEdges

	n=ac_objectget(parName,-1)
	if n<9 then
		return nil
	end

	x2=0
	y2=0
	i=1
	prevx=nil
	midx=nil

	dest=0
	tblEdges={}

	while i+2<=n do
		x=ac_objectget(parName, i)
		y=ac_objectget(parName, i+1)
		status=ac_objectget(parName, i+2)
		if status<100 then
			-- Includes end point
			if x>x2 then
				x2=x
			end
			if y>y2 then
				y2=y
			end

			if prevx and (math.abs(x-prevx)>EPS or math.abs(y-prevy)>EPS) then
				-- New edge
				tbl={}
				tbl.x1=prevx
				tbl.y1=prevy
				tbl.x2=x
				tbl.y2=y
				dest=dest+1
				tblEdges[dest]=tbl
			end

			if status<0 then
				break
			end
			prevx=x
			prevy=y
			midx=nil
		elseif status>=900 and status<1000 then
			-- Circle center
			midx=x
			midy=y
		elseif status>=4000 and status<4100 then
			-- Arc/full circle, y=angledeg, if angle==360 then x=radius

			if math.abs(y)>359 then
				AddCncErr(0, string.format("Unsupported full circle in table %s", parName))
			else
				-- Arc
				local	a, r, dx, dy

--ac_environment("tolog", string.format("prevx=%f prevy=%f", prevx, prevy))
				tbl={}

				dy=prevy-midy
				dx=prevx-midx
				a=math.atan2(dy, dx)
				r=math.sqrt(dx*dx + dy*dy)
				tbl.anglebegrad=a
				a=a+y*PI/180

				tbl.x1=prevx
				tbl.y1=prevy

				tbl.x2=midx+math.cos(a)*r
				tbl.y2=midy+math.sin(a)*r

				tbl.isarc=true
				tbl.midx=midx
				tbl.midy=midy
				tbl.anglelenrad=y*PI/180

				dest=dest+1
				tblEdges[dest]=tbl

				prevx=tbl.x2
				prevy=tbl.y2

				if tbl.x2>x2 then
					x2=tbl.x2
				end
				if tbl.y2>y2 then
					y2=tbl.y2
				end
			end
		else
			AddCncErr(0, string.format("Unsupported length shape code %d in table %s", status, parName))
		end
		i=i+3
	end

	tblBox={}
	tblBox.x1=0
	tblBox.y1=0
	tblBox.x2=x2
	tblBox.y2=y2
	tblBox.hasbot=true
	tblBox.hastop=true

	-- Check if straight top or bottom
	for i,v in ipairs(tblEdges) do
		if not v.isarc and math.abs(v.y1-v.y2)<EPS and (v.x1<EPS and v.x2>x2-EPS or v.x2<EPS and v.x1>x2-EPS) then
			if v.y1<EPS then
				tblBox.hasbot=false
			end
			if v.y1>faceHeight-EPS then
				tblBox.hastop=false
			end
		end
	end

	tbl={}
	tbl.box=tblBox
	tbl.edges=tblEdges

--DumpTbl( tbl.edges )

	return tbl
end


-- Swaps coordinates to the plank's end and swaps direction of the polygon (to keep ccw)
function BtlProfPolyToEnd(tblEnd, plankLen)
	local i, v, n

	for i,v in ipairs(tblEnd.edges) do
		v.x1,v.y1,v.x2,v.y2=plankLen-v.x2, v.y2, plankLen-v.x1, v.y1			-- Swap coords

		if v.isarc then
			v.midx=plankLen-v.midx
			v.anglebegrad=math.atan2(v.y1-v.midy, v.x1-v.midx)
			-- Not changing: v.anglelenrad
		end
	end

	-- Need to swap order also
	n=#tblEnd.edges

	for i=1,math.floor(n/2) do
		v=tblEnd.edges[i]
		tblEnd.edges[i]=tblEnd.edges[n+1-i]
		tblEnd.edges[n+1-i]=v
	end

	tblEnd.box.x1,tblEnd.box.x2=plankLen-tblEnd.box.x2, plankLen-tblEnd.box.x1
end



function BtlIsPlankContour(edge, box, faceHeight)
	if math.abs(edge.y1-edge.y2)<EPS then
		if edge.y1<EPS or edge.y1>faceHeight-EPS then
			return true
		end
	end

	if math.abs(edge.x1-edge.x2)<EPS then
		if edge.x1-EPS<box.x1 or edge.x1+EPS>box.x2 then
			return true
		end
	end

	-- Not at polygon/plank contour
	return false
end


-- tblPoly		From BtlProfPolyToEdges
-- limitTopBot	-1=bottom only, 0=all, 1=top only
-- tblCnc		cnc-table
-- cncindex		where to insert the mcs, also fist PROCESSIDENT: x
-- x2clip		nil=no clipping, value=where to clip the right hand side. Edits polygon if clipping occurs.
-- Returns number of machinings added
function BtlInsertProfTbl(tblPoly, limitTopBot, findBot, faceHeight, tblCnc, cncindex, x2clip)
	local i, n, v, i1, cnc, cncindexorg

	cncindexorg=cncindex

	-- Find first item for top side (ccw) if begin or bottom if end
	i1=nil
	for i,v in ipairs(tblPoly.edges) do
		if findBot==false then
			if v.x1+EPS>tblPoly.box.x2 then
				if i1==nil or v.y1>tblPoly.edges[i1].y1 then
					i1=i
				end
			end
		else
			if v.x1-EPS<tblPoly.box.x1 then
				if i1==nil or v.y1<tblPoly.edges[i1].y1 then
					i1=i
				end
			end
		end
	end

	if not i1 then
		AddCncErr(0, string.format("ERROR: Cannot find starting point for contour shape - skipping contour at x1=%f x2=%f", tblPoly.box.x1, tblPoly.box.x2) )
		return 0
	end

	-- i1 points to the starting point
	local	tblAdd, addCount			-- Add field edgeindex 1...N to items: tells collect number to know if it continues with next
	local   skipEdge

	tblAdd={}
	addCount=0
	n=#tblPoly.edges
	-- Add all skipping straight edges on plank edges
	for i=1,n do
		v=tblPoly.edges[i1]

		skipEdge=false
		if x2clip then
			local	begout, endout, dist

			-- Starting point right from clipping line?
			dist=ac_geo("linedist", x2clip, -1, x2clip, faceHeight+1, v.x1, v.y1)
			if dist>-EPS then
				begout=true
			end

			dist=ac_geo("linedist", x2clip, -1, x2clip, faceHeight+1, v.x2, v.y2)
			if dist>-EPS then
				endout=true
			end

			if begout and endout then
				skipEdge=true
			elseif begout or endout then
				local xx, yy

				xx,yy=ac_geo("linex", x2clip, -1, x2clip, faceHeight+1, v.x1, v.y1, v.x2, v.y2)
				if begout then
					v.x1=xx
					v.y1=yy
				else
					v.x2=xx
					v.y2=yy
				end
			end
		end


		if skipEdge==false then
			if v.isarc or not BtlIsPlankContour(v, tblPoly.box, faceHeight) then
				-- Add this edge
				addCount=addCount+1
				tblAdd[addCount]=v
				v.edgeindex=i
			end
		end

		if limitTopBot<0 then
			if v.x2+EPS>tblPoly.box.x2 then
				break
			end
		elseif limitTopBot>0 then
			if v.x1-EPS<tblPoly.box.x1 then
				break
			end
		end

		-- To next pt
		i1=i1+1
		if i1>n then
			i1=1
		end
	end

--DumpTbl(tblAdd)

	-- Add all collected edges
	local	s, nextindex, isBeg, tbl

	isBeg=true
	for i,v in ipairs(tblAdd) do
		if isBeg then
			-- Add starting point
			segtype=10				-- Line
			contourType=20			-- Mill contour
			if isBeg then
				segType=0			-- Starting point
				contourType=0		-- Fee contour
			end

			s=string.format(
			"PROCESSKEY:  4-250-%d        Free contour\n" ..
			"PROCESSPARAMETERS: P01:%08.0f P02:%08.0f P03:00000000 P05:00000000 P06:00000000 P07:00000000 P08:00000000 P09:%08d P13:00000000",
			--ADDED WHEN WRITTEN: "PROCESSIDENT: %d",
			BtlGetSide14(2),				-- PROCESSKEY:  4-250-%d
			v.x1*10000,
			v.y1*10000,
			(cncindex+1)*10				-- P09
			--cncindex						-- PROCESSIDENT
			)

			tbl={}
			tbl.text=s			-- pos and count not needed

			table.insert( tblCnc, cncindex, tbl )
			cncindex=cncindex+1
		end

		nextindex=cncindex+1
		if i==#tblAdd or v.edgeindex+1~=tblAdd[i+1].edgeindex then
			-- Terminate path
			nextindex=0
		end

		s=nil
		if v.isarc then
			-- Arc segment
			local arcx, arcy, a, r

			-- Calc point at middle of the arc
			a=v.anglebegrad + v.anglelenrad*0.5
			arcx=v.x1-v.midx
			arcy=v.y1-v.midy
			r=math.sqrt(arcx*arcx + arcy*arcy)
			arcx=v.midx+math.cos(a)*r
			arcy=v.midy+math.sin(a)*r

			s=string.format(
			"PROCESSKEY:  4-250-%d        Free contour\n" ..
			"PROCESSPARAMETERS: P01:%08.0f P02:%08.0f P03:00000000 P05:00000000 P06:00000000 P07:00000000 P08:00000020 P09:%08d P10:%08.0f P11:%08.0f P12:00000000 P13:00000020",
			--ADDED WHEN WRITTEN: "PROCESSIDENT: %d",
			BtlGetSide14(2),				-- PROCESSKEY:  4-250-%d
			v.x2*10000,
			v.y2*10000,
			nextindex*10,					-- P09
			arcx*10000,
			arcy*10000
			--cncindex						-- PROCESSIDENT
			)	
		else
			-- Line segment
			s=string.format(
			"PROCESSKEY:  4-250-%d        Free contour\n" ..
			"PROCESSPARAMETERS: P01:%08.0f P02:%08.0f P03:00000000 P05:00000000 P06:00000000 P07:00000000 P08:00000010 P09:%08d P13:00000020",
			--ADDED WHEN WRITTEN: "PROCESSIDENT: %d",
			BtlGetSide14(2),				-- PROCESSKEY:  4-250-%d
			v.x2*10000,
			v.y2*10000,
			nextindex*10					-- P09
			--cncindex						-- PROCESSIDENT
			)	
		end

		if s then
			tbl={}
			tbl.text=s			-- pos and count not needed

			table.insert( tblCnc, cncindex, tbl )
			cncindex=cncindex+1
		end

		isBeg=false
		if nextindex==0 then
			isBeg=true
		end
	end

	return cncindex-cncindexorg
end


-- Like BtlInsertProfTbl but takes x1,x2 and multiplies polygon on that area & handles top and bottom separately
function BtlInsertProfTblMid(tblPoly, faceHeight, tblCnc, cncindex, x1, x2)
	local	xoff, i, v, res, resTot, x2clip

	resTot=0
	xoff=x1
	while x1+0.001<x2 do
		for i,v in ipairs(tblPoly.edges) do
			v.x1=v.x1+xoff
			v.x2=v.x2+xoff
			if v.midx then
				v.midx=v.midx+xoff
			end
		end
		tblPoly.box.x1=tblPoly.box.x1+xoff
		tblPoly.box.x2=tblPoly.box.x2+xoff

		x2clip=x1+tblPoly.box.x2-tblPoly.box.x1
		if x2clip<x2 then
			x2clip=nil
		else
			x2clip=x2
		end

		res=BtlInsertProfTbl(tblPoly, -1, true, faceHeight, tblCnc, cncindex+resTot, x2clip)
		resTot=resTot+res

		res=BtlInsertProfTbl(tblPoly, 1, false, faceHeight, tblCnc, cncindex+resTot, x2clip)
		resTot=resTot+res

--ac_environment("tolog", string.format("tblPoly.box.x1=%f tblPoly.box.x2=%f", tblPoly.box.x1, tblPoly.box.x2))

		xoff=tblPoly.box.x2-tblPoly.box.x1
		x1=x1+xoff
		if xoff<0.001 then
			break
		end
	end

	return resTot
end

-- ### Lengthwise profile END



-- Called before writing new cnc-file - resets globals
function BvnOnInit()
	gnCncErrCount=0
	gtblUsedIds = {}
	gnBtlPieceNum=1
	gtblBtlElemQuant={}
end

-- CODE SHARED WITH ARCHIFRAME END <--
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------
-- ARCHIFRAME ONLY


function SettingsDlg()
	local	tblSettings

	tblSettings={}

	tblSettings[1]			={}
	tblSettings[1].cfgonly	=0
	tblSettings[1].type		=3
	tblSettings[1].prompt	="Groove minimum width"
	tblSettings[1].key		="growidth"
	tblSettings[1].defvalue	=0

	tblSettings[2]			={}
	tblSettings[2].cfgonly	=0
	tblSettings[2].type		=2
	tblSettings[2].prompt	="Write top & bottom plates to separate files"
	tblSettings[2].key		="numplanks"
	tblSettings[2].defvalue	=0

	tblSettings[3]			={}
	tblSettings[3].cfgonly	=0
	tblSettings[3].type		=2
	tblSettings[3].prompt	="Write just one top & bottom file [base]_topbot.btl"
	tblSettings[3].key		="topbot"
	tblSettings[3].defvalue	=0

	tblSettings[4]			={}
	tblSettings[4].cfgonly	=0
	tblSettings[4].type		=2
	tblSettings[4].prompt	="Move grooves on side 1 mm from end (only top&bot pcs)"
	tblSettings[4].key		="movegroend"
	tblSettings[4].defvalue	=0

	tblSettings[5]			={}
	tblSettings[5].cfgonly	=1
	tblSettings[5].type		=4
	tblSettings[5].prompt	="Part ID content printed to wood, empty=no"
	tblSettings[5].key		="btlpartid"
	tblSettings[5].defvalue	="(#fullid#)"

	tblSettings[6]			={}
	tblSettings[6].cfgonly	=0
	tblSettings[6].type		=3
	tblSettings[6].prompt	="Part ID mid from end (pos=from end, neg=from beg)"
	tblSettings[6].key		="btlpartidfromend"
	tblSettings[6].defvalue	=0.370

	tblSettings[7]			={}
	tblSettings[7].cfgonly	=0
	tblSettings[7].type		=3
	tblSettings[7].prompt	="Part ID top from surface bottom"
	tblSettings[7].key		="btlpartidfrombot"
	tblSettings[7].defvalue	=0.046

	tblSettings[8]			={}
	tblSettings[8].cfgonly	=0
	tblSettings[8].type		=2
	tblSettings[8].prompt	="Mark reinforcements"
	tblSettings[8].key		="btlmarkreinforce"
	tblSettings[8].defvalue	=1

	tblSettings[9]			={}
	tblSettings[9].cfgonly	=1
	tblSettings[9].type		=2
	tblSettings[9].prompt	="Save into separate files based on element IDs"
	tblSettings[9].key		="btlsepfiles"
	tblSettings[9].defvalue	=gnBtlWriteSepFiles

	tblSettings[10]			={}
	tblSettings[10].cfgonly	=1
	tblSettings[10].type		=2
	tblSettings[10].prompt	="For element-related pieces save just core-layer"
	tblSettings[10].key		="btlonlycore"
	tblSettings[10].defvalue	=gnBtlWriteOnlyCore

	tblSettings[11]			 ={}
	tblSettings[11].cfgonly	 =1
	tblSettings[11].type	 =1
	tblSettings[11].prompt	 ="Write UID and TRANSFORMATION (3D information)"
	tblSettings[11].key		 ="btluid"
	tblSettings[11].defvalue =1
	tblSettings[11].valuelist="\"1:Yes (default)\",\"2:No to write as before 4/2024\""

    gHelpAnchor="afdlgbtlexport"
	bRes,sErr=ac_optiondlg("LDBB", "Weinmann BTL-writing settings", tblSettings)
	if not bRes then
		return false
	end

	gnBtlMinGroWidth=tblSettings[1].value

	gbBtlTopBottomFile=tblSettings[2].value
	if gbBtlTopBottomFile==0 then
		gbBtlTopBottomFile=false
	else
		gbBtlTopBottomFile=true
	end

	gbBtlTopBottomSingle=tblSettings[3].value
	if gbBtlTopBottomSingle==0 then
		gbBtlTopBottomSingle=false
	else
		gbBtlTopBottomSingle=true
		gbBtlTopBottomFile=true
	end

	gbBtlMoveGroFromEnd=false
	if tblSettings[4].value==1 then
		gbBtlMoveGroFromEnd=true
	end

	gsBtlPartId=tblSettings[5].value
	gnBtlPartIdFromEnd=tblSettings[6].value
	gnBtlPartIdTopFromBot=tblSettings[7].value

	gbBtlMarkReinforce=true
	if tblSettings[8].value==0 then
		gbBtlMarkReinforce=false
	end	

	gnBtlWriteSepFiles	=tblSettings[9].value
	gnBtlWriteOnlyCore	=tblSettings[10].value

	gbBtlWriteUid=true
	if tblSettings[11].value==2 then
		gbBtlWriteUid=false
	end

	return true
end


-- Called before save as dialog is showed
-- strPlnFileName	-> Full path file name of current pln WITHOUT extension (.pln removed)
-- Return values (multiple ret values):
-- 1=listing file name WITH extension, ""=Just prompt with file dlg, starting with *=result contains full path name - do not prompt
-- 2=file extension to be used in save as dialog
function OnInit(strPlnFileName)
	local	projNum = ac_environment("parsetext", "<PROJECTNUMBER>")

	if not SettingsDlg() then
		gbCancel=true
		return
	end

	BvnOnInit()
	sFileName=projNum .. ".btl"
	sExt="btl"

	return sFileName, sExt
end


function BtlDoFileName(strFileName, strAdd)
	local path, fname, ext

	path, fname, ext=SplitFileName(strFileName, strNum)
	return string.format("%s%s%s%s", path, fname, strAdd, ext)
end


-- Called to do all that needs to be done
-- strFileName is full path name for the result file
function OnSaveList(strFileName)
	-- Edit BVN-settings here
	gnBtlPlateSide=EBtlMale
	gnBtlLogDir=EBtlDirBeg

	-- For TRANSFORMATION
	gnOrigX,gnOrigY,gnOrigZ=ac_environment("userorigin")

	if gnBtlWriteOnlyCore==1 then
		-- Filter out anything related to elements but not into core layer
		local	tblPlanksNew, nPlanksNew, elemType, tblElem
		local	tblElemTypes			-- key=guid, value: 0=not core, 1=is core

		tblElemTypes={}
		tblPlanksNew={}
		nPlanksNew=0
		i=1
		while true do
			v=gTblPlanks[i]
			if v==nil then
				break
			end
			i=i+1

			ac_objectopen(v)
			tblRes=af_request("plankinfo", v)
			ac_objectclose()

			owner=tblRes.ownerelemguid

			if owner~=nil then
				-- Check that owner element type is core
				elemType=tblElemTypes[owner]
				if elemType==nil then
					-- Not known - open element
					local	ke, ve, currType

					tblElem=af_request("elem_openparent", owner)

					for ke,ve in ipairs(tblElem.tblelems) do
						currType=0
						if ve.type=="core" then
							currType=1
						end
						tblElemTypes[ve.guid]=currType
					end

					elemType=tblElemTypes[owner]
				end
				if elemType==1 then
					-- Core, add it
					owner=nil
				end
				-- Leave owner set not to be included
			end

			if not owner then
				nPlanksNew=nPlanksNew+1
				tblPlanksNew[nPlanksNew]=v
			end
		end

		gTblPlanks=tblPlanksNew
	end

	if gnBtlWriteSepFiles>0 then
		-- Choose file for each plank, planks are sorted by id
		local tblPlankFiles
		local ownerNone, planksNow, tblRes, owner

		-- Fields: numPlanks=number of collected planks, tblPlanks=plank list, sortkey
		ownerNone="$$$NO OWNER$$$"
		tblPlankFiles={}		-- key=owner=element id or one of above

		i=1
		while true do
			v=gTblPlanks[i]
			if v==nil then
				break
			end

			ac_objectopen(v)

			-- Related to any element?
			tblRes=af_request("plankinfo", v)
			owner=tblRes.ownerelemid
			if owner==nil then
				owner=ownerNone
			end

			planksNow=tblPlankFiles[owner]
			if planksNow==nil then
				planksNow={}
				planksNow.numPlanks=0
				planksNow.tblPlanks={}

				planksNow.sortkey=owner
				planksNow.owner=owner
				tblPlankFiles[owner]=planksNow
			end

			planksNow.numPlanks=planksNow.numPlanks+1
			planksNow.tblPlanks[planksNow.numPlanks]=v

			ac_objectclose(v)
			i=i+1
		end

		local key, value, tblSorted, elemsCount
	
		tblSorted={}
		elemsCount=0
		for key,value in pairs(tblPlankFiles) do
			elemsCount=elemsCount+1
			tblSorted[elemsCount]=value
		end
	
		table.sort(tblSorted, function (n1, n2)
			return n1.sortkey < n2.sortkey
		end)

		for key,value in ipairs(tblSorted) do
			gnBtlPieceNum=nil
			gTblPlanks=value.tblPlanks
			owner=value.owner

			gnBtlPieceNum=nil
			gBtlForceId=nil
			gnUid=1

			if owner==ownerNone then
				--Write without any addition to the file name
				BtlOnSaveListInt(strFileName, true)
			else
				fname=BtlDoFileName(strFileName, "_" .. owner)
				BtlOnSaveListInt(fname, true)
			end
		end
	else
		-- All into single file
		gnBtlPieceNum=nil
		gBtlForceId=nil
		gnUid=1
		BtlOnSaveListInt(strFileName, true)
	end
	
	if false then
		-- Debug all feeding variations
		local dir, plate

		ac_msgbox( "TESTING, PLANK FED ALL WAYS" )
		
		gbBvnForceUnid=true
		for dir=0,0 do
			gnBtlLogDir=dir
			for plate=0,3 do
				gnBtlPlateSide=plate
				gBtlForceId=string.format("%s gnBtlPlateSide=%d", gsCurrentLogId, plate)
				gtblUsedIds = {}	
				BtlOnSaveListInt(strFileName, false)
				gBtlForceId=nil
			end
		end
	end
end


function BtlParseElemGroupSort(s)
	if string.match(s, "bottom_.*") then
		return "b"
	end

	if string.match(s, "top_.*") or string.match(s, "contourtilted") then
		return "c"
	end

	return "a"
end


function BtlPlankCmpElemGroupFull(p1, p2)
	local s1, s2

	if p1.id<p2.id then
		return -1
	end

	if p1.id>p2.id then
		return 1
	end

	if not gbBtlTopBottomFile then
		return 0
	end

	s1=BtlParseElemGroupSort(p1.elemgroup)
	s2=BtlParseElemGroupSort(p2.elemgroup)
	if s1<s2 then
		return -1
	end

	if s1>s2 then
		return 1
	end

	return 0
end


-- Called to do all that needs to be done
-- strFileName is full path name for the result file
function BtlOnSaveListInt(strFileName, bWriteHeader)
	local i, id, v
	local tblSortedPlanks
	local sTotPlank
	local sBotCnc, sBotNoCnc, sTopCnc, sTopNoCnc, sTopBotCnc
	local elemGroup, fileName


	-- Start writing
	sTotPlank=""
	sBotCnc=""
	sBotNoCnc=""
	sTopCnc=""
	sTopNoCnc=""
	sTopBotCnc=""			-- If gbBtlTopBottomSingle

	tblSortedPlanks={}
	i=1
	while true do
		v=gTblPlanks[i]
		if v==nil then
			break
		end

		ac_objectopen(v)
		tblSortedPlanks[i]={}
		tblSortedPlanks[i].guid=v
		tblSortedPlanks[i].id=ac_objectget("#id")
		tblSortedPlanks[i].elemgroup=ac_objectget("iElemGroup")
		ac_objectclose(v)

		i=i+1
	end

	table.sort(tblSortedPlanks, function(p1, p2) return BtlPlankCmpElemGroupFull(p1,p2)<0 end)

	i=1
	while true do
		if tblSortedPlanks[i]==nil then
			break
		end
		gsCurrentLogId=tblSortedPlanks[i].id
		
		if gbBtlTopBottomFile then
			CheckId(string.format("%s/%s", gsCurrentLogId, tblSortedPlanks[i].elemgroup) )
		else
			CheckId(gsCurrentLogId)
		end
		
		-- Calculate how many with the same ID and write them at once
		local nSimilarCount, tblSimilarPos

		nSimilarCount=1
		tblSimilarPos={}
		tblSimilarPos[nSimilarCount]={}
		tblSimilarPos[nSimilarCount].guid=tblSortedPlanks[i].guid

		while tblSortedPlanks[i+nSimilarCount]~=nil do
			if BtlPlankCmpElemGroupFull(tblSortedPlanks[i], tblSortedPlanks[i+nSimilarCount])~=0 then
				break
			end
			nSimilarCount=nSimilarCount+1
			tblSimilarPos[nSimilarCount]={}
			tblSimilarPos[nSimilarCount].guid=tblSortedPlanks[i+nSimilarCount-1].guid
		end

		ac_objectopen(tblSortedPlanks[i].guid)
		elemGroup=ac_objectget("iElemGroup")
		BtlWritePlank( tblSortedPlanks[i].guid, nSimilarCount, tblSimilarPos )			-- Sets gsCncText and gbAnyCnc
		ac_objectclose(tblSortedPlanks[i].guid)

		if gbBtlTopBottomFile then
			if string.match(elemGroup, "top_.*") or string.match(elemGroup, "contourtilted") then
				-- Top piece
				if gbBtlTopBottomSingle then
					sTopBotCnc = sTopBotCnc .. gsCncText
				elseif gbAnyCnc then
					sTopCnc = sTopCnc ..  gsCncText
				else
					sTopNoCnc = sTopNoCnc ..  gsCncText
				end
				gsCncText=nil
			elseif string.match(elemGroup, "bottom_.*") then
				-- Top piece
				if gbBtlTopBottomSingle then
					sTopBotCnc = sTopBotCnc .. gsCncText
				elseif gbAnyCnc then
					sBotCnc = sBotCnc ..  gsCncText
				else
					sBotNoCnc = sBotNoCnc ..  gsCncText
				end
				gsCncText=nil
			end
		end

		if gsCncText then
			sTotPlank=sTotPlank .. gsCncText
		end

		i=i+nSimilarCount
	end

	gsCncText=nil
	
	if sTotPlank~="" then
		BtlWriteFile( bWriteHeader, strFileName, sTotPlank )
	end

	fileName=BtlGetSpecialFileName( strFileName, "_bot_machining" )
	os.remove(fileName)
	if sBotCnc~="" then
		BtlWriteFile( bWriteHeader, fileName, sBotCnc )
	end

	fileName=BtlGetSpecialFileName( strFileName, "_bot_plain" )
	os.remove(fileName)
	if sBotNoCnc~="" then
		BtlWriteFile( bWriteHeader, fileName, sBotNoCnc )
	end

	fileName=BtlGetSpecialFileName( strFileName, "_top_machining" )
	os.remove(fileName)
	if sTopCnc~="" then
		BtlWriteFile( bWriteHeader, fileName, sTopCnc )
	end

	fileName=BtlGetSpecialFileName( strFileName, "_top_plain" )
	os.remove(fileName)
	if sTopNoCnc~="" then
		BtlWriteFile( bWriteHeader, fileName, sTopNoCnc )
	end

	fileName=BtlGetSpecialFileName( strFileName, "_topbot" )
	os.remove(fileName)
	if sTopBotCnc~="" then
		BtlWriteFile( bWriteHeader, fileName, sTopBotCnc )
	end
end



-- Returns path,file name and extension. nil=cannot find
function SplitFileName(strPathName)
	local path, fname, ext
	local i, c, extIndex

	i=string.len(strPathName)
	extIndex=i
	while i>0 do
		c=string.sub(strPathName, i, i)
		if ext==nil and c=="." then
			ext=string.sub(strPathName, i, string.len(strPathName))
			extIndex=i-1
		elseif fname==nil and (c=="\\" or c=="/") then
			fname=string.sub(strPathName, i+1, extIndex)
			path=string.sub(strPathName, 1, i)
			break
		end
		i=i-1
	end
	
	return path,fname,ext
end


function BtlGetSpecialFileName(strFileName, strAdd)
	local path, fname, ext

	path, fname, ext=SplitFileName(strFileName, strNum)
	return string.format("%s%s%s%s", path, fname, strAdd, ext)
end


function BtlWriteFile( bWriteHeader, strFileName, sTotPlank )
	local hFile

	if bWriteHeader then
		hFile=io.open(strFileName, "wt")
	else
		hFile=io.open(strFileName, "at")
	end

	io.output( hFile )

	if bWriteHeader then
		-- btl-header...
		local	s
		local	projNum		= ac_environment("parsetext", "<PROJECTNUMBER>")
		local	projName	= ac_environment("parsetext", "<PROJECTNAME>")
		local	custName	= ac_environment("parsetext", "<CLIENT>")

		s=string.format(
			"VERSION: \"BTL V10.6\"\n" ..
			"BUILD:   \"10400\"\n" ..
			"EDITION: PREFABRICATION\n" ..
			"[GENERAL]\n" ..
			"PROJECTNUMBER: \"%s\"\n" ..
			"PROJECTNAME:   \"%s\"\n" ..
			"PROJECTPART:   \"\"\n" ..
			"LISTNAME:      \"ARCHIFRAME\"\n" ..
			"CUSTOMER:      \"%s\"\n" ..
			"ARCHITECT:     \"\"\n" ..
			"EDITOR:        \"\"\n" ..
			--"DELIVERYDATE:  \"0:00:00\"\n" ..
			--"EXPORTDATE:    \"2011-12-12\"\n" ..
			--"EXPORTTIME:    \"14:54:11\"\n" ..
			"EXPORTRELEASE: \"ArchiFrame BTL 2012-06-01\"\n" ..
			"LANGUAGE:      \"EN\"\n" ..
			"SCALEUNIT:     1\n" ..
			"PROCESSINGQUALITY: AUTOMATIC\n" ..
			"COMPUTERNAME:  \"\"\n" ..
			"USER:          \"\"\n" ..
			"SOURCEFILE:    \"\"\n" ..
			"EXPORTFILE:    \"\"\n" ..
			"RECESS:        AUTOMATIC\n" ..
			"COMMENT:       \"\"\n",
			ToBtl(projNum),
			ToBtl(projName),
			ToBtl(custName)
		)

		io.write(s)
		-- ...btl-header
	end

	io.write( sTotPlank )
	io.close( hFile )
end


-----------------------------------------------------------------------------
-- BTL specific constants

gnBtlStartEndOffset	= 0.020					-- How much waste wood at beg & end of the piece in meters

-- Feeding into machine
gnBtlPlateSide=EBtlMale
gnBtlLogDir=EBtlDirBeg
gbBtlCalcFeed=true							-- If set to true, plank is fed so that longer extent lies on table (overrides previous settings)
gsBtlPartId="(#fullid)"						-- Plank ID as marking machining, replaced: #fullid#, #projid#
gnBtlBestPrintSide=4						-- Depends on the feeding direction: ID and nail marks are placed on this surface

gnBtlMinGroWidth=0								-- The cutter diameter (keep middle line and make it wider if necessary), nil/0=no change
gbBtlTopBottomFile=false						-- Write top & bottom pieces to separate file?
gbBtlTopBottomSingle=false						-- Just single base_topbot.btl?
gbBtlMarkReinforce=true  -- Previous replaced with this 9/2019
gbBtlMoveGroFromEnd=false						-- Move groove from end 1 mm inwards (faces 1-4 only)
gnBtlWriteSepFiles=0							-- 0=All into single file, 1=split by owning element ID
gnBtlWriteOnlyCore=0							-- 0=write all, 1=if part of element, write only core layer
gbBtlWriteUid=true								-- Added 4/2024: true=write UID and TRANSFORMATION, false=as before do not write