Passage en Zinc

1 files changed, 98 insertions, 98 deletions

diff --git a/generic/Transfo.c b/generic/Transfo.c
index aa50303..0d7e95e 100644
--- a/generic/Transfo.c
+++ b/generic/Transfo.c
@@ -77,19 +77,19 @@ static const char compile_id[]="$Compile: " __FILE__ " " __DATE__ " " __TIME__ "
 /*
  *************************************************************************
  *
- * RadarTransfoNew --
+ * ZnTransfoNew --
  *	Create a new transformation and return it initialized to
  *	identity.
  * 
  *************************************************************************
  */
-RadarTransfo *
-RadarTransfoNew()
+ZnTransfo *
+ZnTransfoNew()
 {
-  RadarTransfo	*t;
+  ZnTransfo	*t;
 
-  t = (RadarTransfo *) malloc(sizeof(RadarTransfo));
-  RadarTransfoSetIdentity(t);
+  t = (ZnTransfo *) malloc(sizeof(ZnTransfo));
+  ZnTransfoSetIdentity(t);
   
   return t;
 }
@@ -98,22 +98,22 @@ RadarTransfoNew()
 /*
  *************************************************************************
  *
- * RadarTransfoDuplicate --
+ * ZnTransfoDuplicate --
  *	Create a new transformation identical to the model t.
  * 
  *************************************************************************
  */
-RadarTransfo *
-RadarTransfoDuplicate(RadarTransfo *t)
+ZnTransfo *
+ZnTransfoDuplicate(ZnTransfo *t)
 {
-  RadarTransfo	*nt;
+  ZnTransfo	*nt;
 
-  nt = (RadarTransfo *) RadarMalloc(sizeof(RadarTransfo));
+  nt = (ZnTransfo *) ZnMalloc(sizeof(ZnTransfo));
   if (t) {
     *nt = *t;
   }
   else {
-    RadarTransfoSetIdentity(nt);
+    ZnTransfoSetIdentity(nt);
   }
   
   return nt;
@@ -123,28 +123,28 @@ RadarTransfoDuplicate(RadarTransfo *t)
 /*
  *************************************************************************
  *
- * RadarTransfoFree --
+ * ZnTransfoFree --
  *	Delete a transformation and free its memory.
  * 
  *************************************************************************
  */
 void
-RadarTransfoFree(RadarTransfo	*t)
+ZnTransfoFree(ZnTransfo	*t)
 {
-  RadarFree(t);
+  ZnFree(t);
 }
 
 
 /*
  *************************************************************************
  *
- * RadarPrintTransfo --
+ * ZnPrintTransfo --
  *	Print the transfo matrix on stdout.
  * 
  *************************************************************************
  */
 void
-RadarPrintTransfo(RadarTransfo	*t)
+ZnPrintTransfo(ZnTransfo	*t)
 {
   printf("(%5g %5g\n %5g %5g\n %5g %5g)\n",
 	 t->_[0][0], t->_[0][1],
@@ -156,16 +156,16 @@ RadarPrintTransfo(RadarTransfo	*t)
 /*
  *************************************************************************
  *
- * RadarTransfoIsIdentity --
+ * ZnTransfoIsIdentity --
  *	Tell if the given transfo is (close to) identity.
  * 
  *************************************************************************
  */
-RadarBool
-RadarTransfoIsIdentity(RadarTransfo	*t)
+ZnBool
+ZnTransfoIsIdentity(ZnTransfo	*t)
 {
-  RadarReal	tmp;
-  RadarBool	res = False;
+  ZnReal	tmp;
+  ZnBool	res = False;
 
   tmp = t->_[0][0] - 1.0;
   res = res & ((tmp < PRECISION_LIMIT) && (tmp > -PRECISION_LIMIT));
@@ -186,22 +186,22 @@ RadarTransfoIsIdentity(RadarTransfo	*t)
 /*
  *************************************************************************
  *
- * RadarTransfoSetIdentity --
+ * ZnTransfoSetIdentity --
  *	Initialize the given transfo to identity.
  * 
  *************************************************************************
  */
 void
-RadarTransfoSetIdentity(RadarTransfo	*t)
+ZnTransfoSetIdentity(ZnTransfo	*t)
 {
-  *t = ((RadarTransfo) {{{1, 0}, {0, 1}, {0, 0}}});
+  *t = ((ZnTransfo) {{{1, 0}, {0, 1}, {0, 0}}});
 }
 
 
 /*
  *************************************************************************
  *
- * RadarTransfoCompose --
+ * ZnTransfoCompose --
  *	Combine two transformations t1 and t2 by post-concatenation.
  *	Returns the resulting transformation.
  *	t2 can be NULL, meaning identity transform. This is used in
@@ -211,13 +211,13 @@ RadarTransfoSetIdentity(RadarTransfo	*t)
  *
  *************************************************************************
  */
-RadarTransfo *
-RadarTransfoCompose(RadarTransfo	*res,
-		    RadarTransfo	*t1,
-		    RadarTransfo	*t2)
+ZnTransfo *
+ZnTransfoCompose(ZnTransfo	*res,
+		 ZnTransfo	*t1,
+		 ZnTransfo	*t2)
 {
   if ((t1 != NULL) && (t2 != NULL)) {
-    register RadarReal	tmp;
+    register ZnReal	tmp;
 
     tmp = t1->_[0][0];
     res->_[0][0] = tmp*t2->_[0][0] + t1->_[0][1]*t2->_[1][0];
@@ -240,7 +240,7 @@ RadarTransfoCompose(RadarTransfo	*res,
     }
   }
   else {
-    RadarTransfoSetIdentity(res);
+    ZnTransfoSetIdentity(res);
   }
   
   return res;
@@ -250,7 +250,7 @@ RadarTransfoCompose(RadarTransfo	*res,
 /*
  *************************************************************************
  *
- * RadarTransfoInvert --
+ * ZnTransfoInvert --
  *	Compute the inverse of the given matrix and return it. This
  *	function makes the assumption that the matrix is affine to
  *	optimize the job. Do not give it a general matrix, this will
@@ -260,11 +260,11 @@ RadarTransfoCompose(RadarTransfo	*res,
  *
  *************************************************************************
  */
-RadarTransfo *
-RadarTransfoInvert(RadarTransfo	*t,
-		   RadarTransfo	*inv)
+ZnTransfo *
+ZnTransfoInvert(ZnTransfo	*t,
+		ZnTransfo	*inv)
 {
-  RadarReal	pos, neg, temp, det_l;
+  ZnReal	pos, neg, temp, det_l;
 
   if (t == NULL) {
     return NULL;
@@ -293,7 +293,7 @@ RadarTransfoInvert(RadarTransfo	*t,
   temp = det_l / (pos - neg); /* Why divide by (pos - neg) ?? */
   
   if (ABS(temp) < PRECISION_LIMIT) {
-    RadarWarning("RadarTransfoInvert : singular matrix");
+    ZnWarning("ZnTransfoInvert : singular matrix");
     return NULL;
   }
   
@@ -319,7 +319,7 @@ RadarTransfoInvert(RadarTransfo	*t,
 /*
  *************************************************************************
  *
- * RadarTransfoDecompose --
+ * ZnTransfoDecompose --
  *	Decompose an affine matrix into translation, scale, shear and
  *	rotation. The different values are stored in the locations
  *	pointed to by the pointer parameters. If some values are not
@@ -330,14 +330,14 @@ RadarTransfoInvert(RadarTransfo	*t,
  *************************************************************************
  */
 void
-RadarTransfoDecompose(RadarTransfo	*t,
-		      RadarPoint	*scale,
-		      RadarPoint	*trans,
-		      RadarReal		*rotation,
-		      RadarReal		*shearxy)
+ZnTransfoDecompose(ZnTransfo	*t,
+		   ZnPoint	*scale,
+		   ZnPoint	*trans,
+		   ZnReal	*rotation,
+		   ZnReal	*shearxy)
 {
-  RadarTransfo	local;
-  RadarReal	shear, len, rot, det;
+  ZnTransfo	local;
+  ZnReal	shear, len, rot, det;
   
   if (t == NULL) {
     /* Identity transform */
@@ -361,12 +361,12 @@ RadarTransfoDecompose(RadarTransfo	*t,
 
   det = (t->_[0][0]*t->_[1][1] - t->_[0][1]*t->_[1][0]);
   if (ABS(det) < PRECISION_LIMIT) {
-    RadarWarning("RadarTransfoDecompose : singular matrix");
+    ZnWarning("ZnTransfoDecompose : singular matrix");
     return;
   }
   
   local = *t;
-  //RadarPrintTransfo(&local);
+  //ZnPrintTransfo(&local);
   /* Get translation part if needed */
   if (trans) {
     trans->x = ABS(local._[2][0]) < PRECISION_LIMIT ? 0 : local._[2][0];
@@ -405,7 +405,7 @@ RadarTransfoDecompose(RadarTransfo	*t,
     //printf("shear %f\n", *shearxy);
   }
   //printf("Matrix after scale & shear extracted\n");
-  //RadarPrintTransfo(&local);
+  //ZnPrintTransfo(&local);
   /* Get rotation */
   /* Check for a coordinate system flip. If det of upper-left 2x2
    * is -1, there is a reflection. If the rotation is < 180° negate
@@ -444,17 +444,17 @@ RadarTransfoDecompose(RadarTransfo	*t,
 /*
  *************************************************************************
  *
- * RadarTransfoEqual --
+ * ZnTransfoEqual --
  *	Return True if t1 and t2 are equal (i.e they have the same
  *	rotation, shear scales and translations). If include_translation
  *	is True the translations are considered in the test.
  *
  *************************************************************************
  */
-RadarBool
-RadarTransfoEqual(RadarTransfo	*t1,
-		  RadarTransfo	*t2,
-		  RadarBool	include_translation)
+ZnBool
+ZnTransfoEqual(ZnTransfo	*t1,
+	       ZnTransfo	*t2,
+	       ZnBool		include_translation)
 {
   if (include_translation) {
     return (t1->_[0][0] == t2->_[0][0] &&
@@ -476,14 +476,14 @@ RadarTransfoEqual(RadarTransfo	*t1,
 /*
  *************************************************************************
  *
- * RadarTransfoHasShear --
+ * ZnTransfoHasShear --
  *	Return True if t has a shear factor in x or y or describe a
  *	rotation or both.
  *
  *************************************************************************
  */
-RadarBool
-RadarTransfoHasShear(RadarTransfo	*t)
+ZnBool
+ZnTransfoHasShear(ZnTransfo	*t)
 {
   return t->_[0][1] != 0.0 || t->_[1][0] != 0.0;
 }
@@ -492,13 +492,13 @@ RadarTransfoHasShear(RadarTransfo	*t)
 /*
  *************************************************************************
  *
- * RadarTransfoIsTranslation --
+ * ZnTransfoIsTranslation --
  *	Return True if t is a pure translation.
  *
  *************************************************************************
  */
-RadarBool
-RadarTransfoIsTranslation(RadarTransfo	*t)
+ZnBool
+ZnTransfoIsTranslation(ZnTransfo	*t)
 {
   return (t->_[0][0] == 0.0 &&
 	  t->_[0][1] == 0.0 &&
@@ -510,7 +510,7 @@ RadarTransfoIsTranslation(RadarTransfo	*t)
 /*
  *************************************************************************
  *
- * RadarTransformPoint --
+ * ZnTransformPoint --
  *	Apply the transformation to the point. The point is
  *	modified and returned as the value of the function.
  *	A NULL transformation means identity. This is only used
@@ -519,10 +519,10 @@ RadarTransfoIsTranslation(RadarTransfo	*t)
  *
  *************************************************************************
  */
-RadarPoint *
-RadarTransformPoint(RadarTransfo	*t,
-		    register RadarPoint	*p,
-		    RadarPoint		*xp)
+ZnPoint *
+ZnTransformPoint(ZnTransfo		*t,
+		 register ZnPoint	*p,
+		 ZnPoint		*xp)
 {
   if (t == NULL) {
     xp->x = p->x;
@@ -539,7 +539,7 @@ RadarTransformPoint(RadarTransfo	*t,
 /*
  *************************************************************************
  *
- * RadarTransformPoints --
+ * ZnTransformPoints --
  *	Apply the transformation to the points in p returning points in xp.
  *	The number of points is in num.
  *	A NULL transformation means identity. This is only used
@@ -549,13 +549,13 @@ RadarTransformPoint(RadarTransfo	*t,
  *************************************************************************
  */
 void
-RadarTransformPoints(RadarTransfo	*t,
-		     RadarPoint		*p,
-		     RadarPoint		*xp,
-		     int		num)
+ZnTransformPoints(ZnTransfo	*t,
+		  ZnPoint	*p,
+		  ZnPoint	*xp,
+		  int		num)
 {
   if (t == NULL) {
-    memcpy(xp, p, sizeof(RadarPoint)*num);
+    memcpy(xp, p, sizeof(ZnPoint)*num);
   }
   else {
     int i;
@@ -571,20 +571,20 @@ RadarTransformPoints(RadarTransfo	*t,
 /*
  *************************************************************************
  *
- * RadarTranslate --
+ * ZnTranslate --
  *	Translate the given transformation by delta_x, delta_y. Returns
  *	the resulting transformation.
  *
- * RadarSetTranslation --
+ * ZnSetTranslation --
  *	Set the translation instead of combining it into the
  *	transformation.
  *
  *************************************************************************
  */
-RadarTransfo *
-RadarTranslate(RadarTransfo	*t,
-	       RadarReal	delta_x,
-	       RadarReal	delta_y)
+ZnTransfo *
+ZnTranslate(ZnTransfo	*t,
+	    ZnReal	delta_x,
+	    ZnReal	delta_y)
 {
   t->_[2][0] = t->_[2][0] + delta_x;
   t->_[2][1] = t->_[2][1] + delta_y;
@@ -592,10 +592,10 @@ RadarTranslate(RadarTransfo	*t,
   return t;
 }
 
-RadarTransfo *
-RadarSetTranslation(RadarTransfo	*t,
-		    RadarReal		delta_x,
-		    RadarReal		delta_y)
+ZnTransfo *
+ZnSetTranslation(ZnTransfo	*t,
+		 ZnReal		delta_x,
+		 ZnReal		delta_y)
 {
   t->_[2][0] = delta_x;
   t->_[2][1] = delta_y;
@@ -607,16 +607,16 @@ RadarSetTranslation(RadarTransfo	*t,
 /*
  *************************************************************************
  *
- * RadarScale --
+ * ZnScale --
  *	Scale the given transformation by scale_x, scale_y. Returns the
  *	resulting transformation.
  *
  *************************************************************************
  */
-RadarTransfo *
-RadarScale(RadarTransfo		*t,
-	   register RadarReal	scale_x,
-	   register RadarReal	scale_y)
+ZnTransfo *
+ZnScale(ZnTransfo	*t,
+	register ZnReal	scale_x,
+	register ZnReal	scale_y)
 {
   t->_[0][0] = t->_[0][0]*scale_x;
   t->_[0][1] = t->_[0][1]*scale_y;
@@ -632,20 +632,20 @@ RadarScale(RadarTransfo		*t,
 /*
  *************************************************************************
  *
- * RadarRotateRad --
+ * ZnRotateRad --
  *	Rotate the given transformation by angle radians
  *	counter-clockwise around the origin. Returns the resulting
  *	transformation.
  *
  *************************************************************************
  */
-RadarTransfo *
-RadarRotateRad(RadarTransfo	*t,
-	       RadarReal	angle)
+ZnTransfo *
+ZnRotateRad(ZnTransfo	*t,
+	    ZnReal	angle)
 {
-  register RadarReal	c = cos(angle);
-  register RadarReal	s = sin(angle);
-  register RadarReal	tmp;
+  register ZnReal	c = cos(angle);
+  register ZnReal	s = sin(angle);
+  register ZnReal	tmp;
 
   tmp = t->_[0][0];
   t->_[0][0] = tmp*c - t->_[0][1]*s;
@@ -664,18 +664,18 @@ RadarRotateRad(RadarTransfo	*t,
 /*
  *************************************************************************
  *
- * RadarRotateDeg --
+ * ZnRotateDeg --
  *	Rotate the given transformation by angle degrees
  *	counter-clockwise around the origin. Returns the resulting
  *	transformation.
  *
  *************************************************************************
  */
-RadarTransfo *
-RadarRotateDeg(RadarTransfo	*t,
-	       RadarReal	angle)
+ZnTransfo *
+ZnRotateDeg(ZnTransfo	*t,
+	    ZnReal	angle)
 {
-  return RadarRotateRad(t, DegreesToRadian(angle));
+  return ZnRotateRad(t, DegreesToRadian(angle));
 }