-- CGOutlinesImpl.mesa
--Written by Doug Wyatt,  Nov-81
-- Last changed by J Warnock June 28, 1982 12:24 pm
--Maureen Stone January 31, 1984 4:27:02 pm PST

DIRECTORY
  ParametricMap,
  CGCubic USING [Bezier],
  GraphicsBasic USING [Vec],
  CGVector USING [Add,Mul,Sub,Dot],
  CGOutlines USING [Data, DataRep, ErrorType, NodeRep, Rep],
  CGStorage USING [pZone, qZone],
  RealFns USING [SqRt];

CGOutlinesImpl: CEDAR PROGRAM
IMPORTS CGStorage,CGVector,ParametricMap,RealFns
EXPORTS CGOutlines = {
OPEN CGOutlines, GraphicsBasic, CGVector, CGCubic;

Ref: TYPE = REF Rep;

Error: PUBLIC ERROR[type: ErrorType] = CODE;

dataZone: ZONE = CGStorage.pZone;
nodeZone: ZONE = CGStorage.qZone;
boxZone: ZONE = CGStorage.qZone;
repZone: ZONE = CGStorage.qZone;


New: PUBLIC PROC[size: NAT] RETURNS[Ref] = {
  self: Ref _ repZone.NEW[Rep _ [size: 0, data: NIL, fpi: 0, fp: [0,0], lp: [0,0], sum:0]];
  [] _ GetData[self,size];
  RETURN[self];
  };

GetData: PROC[self: Ref, size: NAT, bump: NAT _ 0] RETURNS[Data] = INLINE {
  data: Data _ self.data;
  space: NAT _ IF data=NIL THEN 0 ELSE data.space;
  IF space<size THEN data _ Grow[self,MAX[size,space+bump]];
  RETURN[data];
  };

Grow: PROC[self: Ref, size: NAT] RETURNS[Data] = {
  old: Data _ self.data;
  space: NAT _ IF old=NIL THEN 0 ELSE old.space;
  new: Data _ dataZone.NEW[DataRep[size]];
  FOR i: NAT IN[0..space) DO new[i] _ old[i] ENDLOOP;
  FOR i: NAT IN[space..size) DO new[i] _ nodeZone.NEW[NodeRep _ nullNode] ENDLOOP;
  self.data _ new;
  RETURN[new];
  };

nullNode:NodeRep=NodeRep[TRUE,0,0,0,0,Bezier[[0,0],[0,0],[0,0],[0,0]]];

MoveTo: PUBLIC PROC[self: Ref, p: Vec] = {
  i: NAT _ self.size;
  self.fpi_i;
  self.fp _ p;
  self.lp _ p;
  };


LineTo: PUBLIC PROC[self: Ref, p: Vec] = {
  l:REAL; -- length of vec
  v:Vec;
  size: NAT;
  data: Data;
  i: NAT _ self.size;
  IF p = self.lp THEN RETURN; --ignore duplicated points.
  size _ i + 1;
  data _ GetData[self,size,MAX[8,MIN[size/2,1024]]];
  v_Sub[p,self.lp];
  l_Mag[v];
  IF i=0 
  	THEN {data[i]^_NodeRep[TRUE,0,0,0,l,
 							Bezier[self.lp,Add[self.lp,Mul[v,1.0/3.0]],Add[self.lp,Mul[v,2.0/3.0]],p]];}
  	ELSE  { s1,s2:REAL;
  			  v1,v2,v3:Vec;
  			  data[i]^_NodeRep[TRUE,0,0,self.sum,self.sum+l,
  			  				Bezier[self.lp,Add[self.lp,Mul[v,1.0/3.0]],Add[self.lp,Mul[v,2.0/3.0]],p]];
  			  v1_Norm[Sub[data[i-1].bz.b3,data[i-1].bz.b2]];
  			  v2_Norm[v];
  			  v3_Norm[Add[v1,v2]];
  			  s1_Dot[Vec[v1.y,-v1.x],v3];
  			  s2_Dot[Vec[v2.y,-v2.x],v3];
  			  data[i-1].a2_s1/RealFns.SqRt[1-s1*s1]; --compute horz vec for angle between v1 & v3
  			  data[i].a1_s2/RealFns.SqRt[1-s2*s2]; --compute horz vec for angle between v2 & v3
  			  };
  self.sum_self.sum+l;
  self.lp _ p;
  self.size _ size;
  };


CurveTo: PUBLIC PROC[self: Ref, b1,b2,b3: Vec] = {
    IF self.lp = b1 
  	THEN 
  	{IF b3 = b2
  		THEN
  		{IF b2 = b1 
  			THEN RETURN  --ignore degenerate cubic.
  			ELSE LineTo[self,b3];
  		}
  		ELSE
  		{IF b2 = b1 
  			THEN LineTo[self,b3]  
  			ELSE FourPoint[self,self.lp,b1,b2,b3];
  		};
  	}
 	ELSE
 	{IF b3 = b2
  		THEN
  		{IF b2 = b1 THEN LineTo[self,b3];}  
  		ELSE FourPoint[self,self.lp,b1,b2,b3];
  	 };
};

Close: PUBLIC PROC[self: Ref] = {
  l:REAL; -- length of vec
  p,p1,v:Vec;
  i: NAT;
  p1_self.fp;
  p_self.data[self.fpi].bz.b1;
  LineTo[self,p1];
  v_Sub[p,p1];
  i_self.size;
  l_Mag[v];
  IF i=0 
  	THEN {ERROR}
  	ELSE  {s1,s2:REAL;
  			  v1,v2,v3:Vec;
  			  v1_Norm[Sub[self.data[i-1].bz.b3,self.data[i-1].bz.b2]];
  			  v2_Norm[v];
  			  v3_Norm[Add[v1,v2]];
  			  s1_Dot[Vec[v1.y,-v1.x],v3];
  			  s2_Dot[Vec[v2.y,-v2.x],v3];
  			  self.data[i-1].a2_s1/RealFns.SqRt[1-s1*s1]; --compute horz vec for angle 
  			  self.data[self.fpi].a1_s2/RealFns.SqRt[1-s2*s2]; --compute horz vec for angle
			  };
   };

FourPoint:PROC[self:Ref,vec1,vec2,vec3,vec4:Vec]=
  	{data: Data;
    l:REAL;
  	v:Vec;
  	i,size:NAT;
  	i_self.size;
  	size _ i + 1;
  	data _ GetData[self,size,MAX[8,MIN[size/2,1024]]];
  	v_Sub[vec2,vec1];
  	l_GetLength[vec1,vec2,vec3,vec4];
  	IF i=0 
  		THEN {data[i]^ _ NodeRep[FALSE,0,0,0,l,Bezier[vec1,vec2,vec3,vec4]];}
  		ELSE  {s1,s2:REAL;
  			  v1,v2,v3:Vec;
  			  data[i]^ _ [FALSE,0,0,self.sum,self.sum+l,Bezier[vec1,vec2,vec3,vec4]];
  			  v1_Norm[Sub[data[i-1].bz.b3,data[i-1].bz.b2]];
  			  v2_Norm[v];
  			  v3_Norm[Add[v1,v2]];
  			  s1_Dot[Vec[v1.y,-v1.x],v3]; --compute sin of angle
  			  s2_Dot[Vec[v2.y,-v2.x],v3]; --compute sin of angle
  			  self.data[i-1].a2_s1/RealFns.SqRt[1-s1*s1]; --compute horz vec for angle  
  			  data[i].a1_s2/RealFns.SqRt[1-s2*s2]; --compute horz vec for angle
  			  };
  	self.sum_self.sum+l;
    self.lp _ vec4;
  	self.size _ size;};

GetMappedVec: PUBLIC PROC[self:Ref,v:Vec] RETURNS [w:Vec]=
  TRUSTED {a1,a2,x,t:REAL;
  pos,dc:Vec;
  bz:Bezier;
  i:NAT;
  i_0;
  IF v.x > self.sum THEN v.x_self.sum;
  UNTIL v.x IN [self.data[i].l1..self.data[i].l2] DO
    i_i+1;
  ENDLOOP;
  bz_self.data[i].bz;
  x_v.x-self.data[i].l1;
  IF self.data[i].line 
  	THEN
  	{t_x/(self.data[i].l2-self.data[i].l1)}
  	ELSE
  	{[,t]_ParametricMap.GetTforArc[@bz,x];};
  [pos,dc]_ParametricMap.GetDirCos[t,@bz];
  a1_self.data[i].a1;
  a2_self.data[i].a2;
  w_Add[pos,Mul[Add[Vec[-dc.y,dc.x],Mul[dc,a1+(a2-a1)*t]],v.y]];
  };
  
  
GetLinkCount:PUBLIC PROC[self:Ref] RETURNS [c:NAT]=
  {RETURN[self.size];};
  
GetLinkLength:PUBLIC PROC[self:Ref,i:NAT] RETURNS [l:REAL]=
  {RETURN[self.data[i].l2-self.data[i].l1];};
  

Copy: PUBLIC PROC[self: Ref] RETURNS[Ref] = {
  size: NAT _ self.size;
  old: Data _ self.data;
  copy: Ref _ New[size];
  new: Data _ copy.data;
  FOR i: NAT IN[0..size) DO new[i]^ _ old[i]^ ENDLOOP;
  copy.size _ size;
  copy.fpi _ self.fpi;
  copy.fp _ self.fp;
  copy.lp _ self.lp;
  RETURN[copy];
  };

Assign: PUBLIC PROC[self: Ref, copy: Ref] = {
  size: NAT _ copy.size;
  new: Data _ copy.data;
  old: Data _ GetData[self,size];
  FOR i: NAT IN[0..size) DO old[i]^ _ new[i]^ ENDLOOP;
  self.size _ size;
  self.fpi _ copy.fpi;
  self.fp _ copy.fp;
  self.lp _ copy.lp;
};

Mag:PROC[v:Vec] RETURNS [REAL]=INLINE
{RETURN[RealFns.SqRt[v.x*v.x+v.y*v.y]];};

Norm:PROC[v:Vec] RETURNS [Vec]=INLINE
{m:REAL_Mag[v];
IF m = 0 THEN RETURN [v] ELSE RETURN [Mul[v,1.0/m]];};

GetLength:PROC[v1,v2,v3,v4:Vec] RETURNS [REAL]=
TRUSTED {bz:CGCubic.Bezier;
bz_CGCubic.Bezier[v1,v2,v3,v4];
RETURN[ParametricMap.ArcLength[@bz]];};

}.