/******************************************************************************
* Cagd_gen.c - General routines used by all modules of CAGD_lib.	      *
*******************************************************************************
* Written by Gershon Elber, Mar. 90.					      *
******************************************************************************/

#include <string.h>
#include "cagd_loc.h"
#include "geomat3d.h"
#include "miscattr.h"

/* Control of the linear order surface convertion to polygon: */
CagdLin2PolyType
    _CagdLin2Poly = CAGD_ONE_POLY_PER_COLIN;

/*****************************************************************************
* DESCRIPTION:                                                               M
* Allocates and copies a list of vector structures.		             M
*                                                                            *
* PARAMETERS:                                                                M
*   VecList:       To be copied.                                             M
*                                                                            *
* RETURN VALUE:                                                              M
*   CagdVecStruct *:  A duplicated list of vectors.                          M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdVecCopyList, copy                                                    M
*****************************************************************************/
CagdVecStruct *CagdVecCopyList(CagdVecStruct *VecList)
{
    CagdVecStruct *VecTemp, *NewVecList;

    if (VecList == NULL)
	return NULL;
    VecTemp = NewVecList = CagdVecCopy(VecList);
    VecList = VecList -> Pnext;
    while (VecList) {
	VecTemp -> Pnext = CagdVecCopy(VecList);
	VecTemp = VecTemp -> Pnext;
	VecList = VecList -> Pnext;
    }
    return NewVecList;
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Allocates and copies a list of plane structures.		             M
*                                                                            *
* PARAMETERS:                                                                M
*   PlaneList:       To be copied.                                           M
*                                                                            *
* RETURN VALUE:                                                              M
*   CagdPlaneStruct *:  A duplicated list of planes.                         M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdPlaneCopyList, copy                                                  M
*****************************************************************************/
CagdPlaneStruct *CagdPlaneCopyList(CagdPlaneStruct *PlaneList)
{
    CagdPlaneStruct *PlaneTemp, *NewPlaneList;

    if (PlaneList == NULL)
	return NULL;
    PlaneTemp = NewPlaneList = CagdPlaneCopy(PlaneList);
    PlaneList = PlaneList -> Pnext;
    while (PlaneList) {
	PlaneTemp -> Pnext = CagdPlaneCopy(PlaneList);
	PlaneTemp = PlaneTemp -> Pnext;
	PlaneList = PlaneList -> Pnext;
    }
    return NewPlaneList;
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Allocates and copies a list of bbox structures.		             M
*                                                                            *
* PARAMETERS:                                                                M
*   BBoxList:       To be copied.                                            M
*                                                                            *
* RETURN VALUE:                                                              M
*   CagdBBoxStruct *:  A duplicated list of bbox's.                          M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdBBoxCopyList, copy                                                   M
*****************************************************************************/
CagdBBoxStruct *CagdBBoxCopyList(CagdBBoxStruct *BBoxList)
{
    CagdBBoxStruct *BBoxTemp, *NewBBoxList;

    if (BBoxList == NULL)
	return NULL;
    BBoxTemp = NewBBoxList = CagdBBoxCopy(BBoxList);
    BBoxList = BBoxList -> Pnext;
    while (BBoxList) {
	BBoxTemp -> Pnext = CagdBBoxCopy(BBoxList);
	BBoxTemp = BBoxTemp -> Pnext;
	BBoxList = BBoxList -> Pnext;
    }
    return NewBBoxList;
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Allocates and copies a list of polyline structures.		             M
*                                                                            *
* PARAMETERS:                                                                M
*   PolyList:       To be copied.                                            M
*                                                                            *
* RETURN VALUE:                                                              M
*   CagdPolylineStruct *:  A duplicated list of polylines.                   M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdPolylineCopyList, copy                                               M
*****************************************************************************/
CagdPolylineStruct *CagdPolylineCopyList(CagdPolylineStruct *PolyList)
{
    CagdPolylineStruct *PolyTemp, *NewPolyList;

    if (PolyList == NULL)
	return NULL;
    PolyTemp = NewPolyList = CagdPolylineCopy(PolyList);
    PolyList = PolyList -> Pnext;
    while (PolyList) {
	PolyTemp -> Pnext = CagdPolylineCopy(PolyList);
	PolyTemp = PolyTemp -> Pnext;
	PolyList = PolyList -> Pnext;
    }
    return NewPolyList;
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Allocates and copies a list of polygon structures.		             M
*                                                                            *
* PARAMETERS:                                                                M
*   PolyList:       To be copied.                                            M
*                                                                            *
* RETURN VALUE:                                                              M
*   CagdPolygontruct *:  A duplicated list of polygons.                      M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdPolygonCopyList, copy                                                M
*****************************************************************************/
CagdPolygonStruct *CagdPolygonCopyList(CagdPolygonStruct *PolyList)
{
    CagdPolygonStruct *PolyTemp, *NewPolyList;

    if (PolyList == NULL)
	return NULL;
    PolyTemp = NewPolyList = CagdPolygonCopy(PolyList);
    PolyList = PolyList -> Pnext;
    while (PolyList) {
	PolyTemp -> Pnext = CagdPolygonCopy(PolyList);
	PolyTemp = PolyTemp -> Pnext;
	PolyList = PolyList -> Pnext;
    }
    return NewPolyList;
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Deallocates and frees all slots of a curve structure.		             M
*                                                                            *
* PARAMETERS:                                                                M
*   Crv:       To be deallocated.                                            M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdCrvFree, free                                                        M
*****************************************************************************/
void CagdCrvFree(CagdCrvStruct *Crv)
{
    int i, MaxAxis;

    if (Crv == NULL)
	return;

    MaxAxis = CAGD_NUM_OF_PT_COORD(Crv -> PType);

    for (i = !CAGD_IS_RATIONAL_CRV(Crv); i <= MaxAxis; i++)
	IritFree((VoidPtr) Crv -> Points[i]);

    if (Crv -> KnotVector != NULL)
	IritFree((VoidPtr) Crv -> KnotVector);

    AttrFreeAttributes(&Crv -> Attr);
    IritFree((VoidPtr) Crv);
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Deallocates and frees a curve structure list:				     M
*                                                                            *
* PARAMETERS:                                                                M
*   CrvList:  To be deallocated.                                             M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdCrvFreeList, free                                                    M
*****************************************************************************/
void CagdCrvFreeList(CagdCrvStruct *CrvList)
{
    CagdCrvStruct *CrvTemp;

    while (CrvList) {
	CrvTemp = CrvList -> Pnext;
	CagdCrvFree(CrvList);
	CrvList = CrvTemp;
    }
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Deallocates and frees all slots of a surface sstructure.	             M
*                                                                            *
* PARAMETERS:                                                                M
*   Srf:       To be deallocated.                                            M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdSrfFree, free                                                        M
*****************************************************************************/
void CagdSrfFree(CagdSrfStruct *Srf)
{
    int i, MaxAxis;

    if (Srf == NULL)
	return;

    MaxAxis = CAGD_NUM_OF_PT_COORD(Srf -> PType);

    for (i = !CAGD_IS_RATIONAL_SRF(Srf); i <= MaxAxis; i++)
	IritFree((VoidPtr) Srf -> Points[i]);

    if (Srf -> UKnotVector != NULL)
	IritFree((VoidPtr) Srf -> UKnotVector);
    if (Srf -> VKnotVector != NULL)
	IritFree((VoidPtr) Srf -> VKnotVector);

    AttrFreeAttributes(&Srf -> Attr);
    IritFree((VoidPtr) Srf);
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Deallocates and frees a surface structure list:			     M
*                                                                            *
* PARAMETERS:                                                                M
*   SrfList:  To be deallocated.                                             M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdSrfFreeList, free                                                    M
*****************************************************************************/
void CagdSrfFreeList(CagdSrfStruct *SrfList)
{
    CagdSrfStruct *SrfTemp;

    while (SrfList) {
	SrfTemp = SrfList -> Pnext;
	CagdSrfFree(SrfList);
	SrfList = SrfTemp;
    }
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Deallocates and frees all slots of a UV structure.		             M
*                                                                            *
* PARAMETERS:                                                                M
*   UV:       To be deallocated.                                             M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdUVFree, free                                                         M
*****************************************************************************/
void CagdUVFree(CagdUVStruct *UV)
{
    if (UV == NULL)
	return;

    AttrFreeAttributes(&UV -> Attr);
    IritFree((VoidPtr) UV);
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Deallocates and frees a UV structure list:				     M
*                                                                            *
* PARAMETERS:                                                                M
*   UVList:  To be deallocated.                                              M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdUVFreeList, free                                                     M
*****************************************************************************/
void CagdUVFreeList(CagdUVStruct *UVList)
{
    CagdUVStruct *UVTemp;

    while (UVList) {
	UVTemp = UVList -> Pnext;
	CagdUVFree(UVList);
	UVList = UVTemp;
    }
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Deallocates and frees an array of UV structure.			     M
*                                                                            *
* PARAMETERS:                                                                M
*   UVArray:     To be deallocated.                                          M
*   Size:        Of the deallocated array.                                   M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdUVArrayFree, free                                                    M
*****************************************************************************/
void CagdUVArrayFree(CagdUVStruct *UVArray, int Size)
{
    int i;

    for (i = 0; i < Size; i++)
	AttrFreeAttributes(&UVArray[i].Attr);

    IritFree((VoidPtr) UVArray);
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Deallocates and frees all slots of a point structure.		             M
*                                                                            *
* PARAMETERS:                                                                M
*   Pt:       To be deallocated.                                             M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdPtFree, free                                                         M
*****************************************************************************/
void CagdPtFree(CagdPtStruct *Pt)
{
    if (Pt == NULL)
	return;

    AttrFreeAttributes(&Pt -> Attr);
    IritFree((VoidPtr) Pt);
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Deallocates and frees a point structure list:				     M
*                                                                            *
* PARAMETERS:                                                                M
*   PtList:  To be deallocated.                                              M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdPtFreeList, free                                                     M
*****************************************************************************/
void CagdPtFreeList(CagdPtStruct *PtList)
{
    CagdPtStruct *PtTemp;

    while (PtList) {
	PtTemp = PtList -> Pnext;
	CagdPtFree(PtList);
	PtList = PtTemp;
    }
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Deallocates and frees an array of Pt structure.			     M
*                                                                            *
* PARAMETERS:                                                                M
*   PtArray:     To be deallocated.                                          M
*   Size:        Of the deallocated array.                                   M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdPtArrayFree, free                                                    M
*****************************************************************************/
void CagdPtArrayFree(CagdPtStruct *PtArray, int Size)
{
    int i;

    for (i = 0; i < Size; i++)
	AttrFreeAttributes(&PtArray[i].Attr);

    IritFree((VoidPtr) PtArray);
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Deallocates and frees all slots of a CtlPt structure.		             M
*                                                                            *
* PARAMETERS:                                                                M
*   CtlPt:       To be deallocated.                                          M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdCtlPtFree, free                                                      M
*****************************************************************************/
void CagdCtlPtFree(CagdCtlPtStruct *CtlPt)
{
    if (CtlPt == NULL)
	return;

    AttrFreeAttributes(&CtlPt -> Attr);
    IritFree((VoidPtr) CtlPt);
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Deallocates and frees a CtlPt structure list:				     M
*                                                                            *
* PARAMETERS:                                                                M
*   CtlPtList:  To be deallocated.                                           M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdCtlPtFreeList, free                                                  M
*****************************************************************************/
void CagdCtlPtFreeList(CagdCtlPtStruct *CtlPtList)
{
    CagdCtlPtStruct *CtlPtTemp;

    while (CtlPtList) {
	CtlPtTemp = CtlPtList -> Pnext;
	CagdCtlPtFree(CtlPtList);
	CtlPtList = CtlPtTemp;
    }
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Deallocates and frees an array of CtlPt structure.			     M
*                                                                            *
* PARAMETERS:                                                                M
*   CtlPtArray:     To be deallocated.                                       M
*   Size:           Of the deallocated array.                                M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdCtlPtArrayFree, free                                                 M
*****************************************************************************/
void CagdCtlPtArrayFree(CagdCtlPtStruct *CtlPtArray, int Size)
{
    int i;

    for (i = 0; i < Size; i++)
	AttrFreeAttributes(&CtlPtArray[i].Attr);

    IritFree((VoidPtr) CtlPtArray);
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Deallocates and frees all slots of a vector structure.		     M
*                                                                            *
* PARAMETERS:                                                                M
*   Vec:       To be deallocated.                                            M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdVecFree, free                                                        M
*****************************************************************************/
void CagdVecFree(CagdVecStruct *Vec)
{
    if (Vec == NULL)
	return;

    AttrFreeAttributes(&Vec -> Attr);
    IritFree((VoidPtr) Vec);
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Deallocates and frees a vector structure list:			     M
*                                                                            *
* PARAMETERS:                                                                M
*   VecList:  To be deallocated.                                             M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdVecFreeList, free                                                    M
*****************************************************************************/
void CagdVecFreeList(CagdVecStruct *VecList)
{
    CagdVecStruct *VecTemp;

    while (VecList) {
	VecTemp = VecList -> Pnext;
	CagdVecFree(VecList);
	VecList = VecTemp;
    }
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Deallocates and frees an array of vector structure.			     M
*                                                                            *
* PARAMETERS:                                                                M
*   VecArray:     To be deallocated.                                         M
*   Size:         Of the deallocated array.                                  M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdVecArrayFree, free                                                   M
*****************************************************************************/
void CagdVecArrayFree(CagdVecStruct *VecArray, int Size)
{
    int i;

    for (i = 0; i < Size; i++)
	AttrFreeAttributes(&VecArray[i].Attr);

    IritFree((VoidPtr) VecArray);
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Deallocates and frees all slots of a plane structure.		             M
*                                                                            *
* PARAMETERS:                                                                M
*   Plane:       To be deallocated.                                          M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdPlaneFree, free                                                      M
*****************************************************************************/
void CagdPlaneFree(CagdPlaneStruct *Plane)
{
    if (Plane == NULL)
	return;

    AttrFreeAttributes(&Plane -> Attr);
    IritFree((VoidPtr) Plane);
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Deallocates and frees a plane structure list:				     M
*                                                                            *
* PARAMETERS:                                                                M
*   PlaneList:  To be deallocated.                                           M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdPlaneFreeList, free                                                  M
*****************************************************************************/
void CagdPlaneFreeList(CagdPlaneStruct *PlaneList)
{
    CagdPlaneStruct *PlaneTemp;

    while (PlaneList) {
	PlaneTemp = PlaneList -> Pnext;
	CagdPlaneFree(PlaneList);
	PlaneList = PlaneTemp;
    }
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Deallocates and frees an array of plane structure.			     M
*                                                                            *
* PARAMETERS:                                                                M
*   PlaneArray:     To be deallocated.                                       M
*   Size:           Of the deallocated array.                                M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdPlaneArrayFree, free                                                 M
*****************************************************************************/
void CagdPlaneArrayFree(CagdPlaneStruct *PlaneArray, int Size)
{
    int i;

    for (i = 0; i < Size; i++)
	AttrFreeAttributes(&PlaneArray[i].Attr);

    IritFree((VoidPtr) PlaneArray);
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Deallocates and frees all slots of a BBox structure.		             M
*                                                                            *
* PARAMETERS:                                                                M
*   BBox:       To be deallocated.                                           M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdBBoxFree, free                                                       M
*****************************************************************************/
void CagdBBoxFree(CagdBBoxStruct *BBox)
{
    if (BBox == NULL)
	return;

    AttrFreeAttributes(&BBox -> Attr);
    IritFree((VoidPtr) BBox);
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Deallocates and frees a BBox structure list:				     M
*                                                                            *
* PARAMETERS:                                                                M
*   BBoxList:  To be deallocated.                                            M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdBBoxFreeList, free                                                   M
*****************************************************************************/
void CagdBBoxFreeList(CagdBBoxStruct *BBoxList)
{
    CagdBBoxStruct *BBoxTemp;

    while (BBoxList) {
	BBoxTemp = BBoxList -> Pnext;
	CagdBBoxFree(BBoxList);
	BBoxList = BBoxTemp;
    }
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Deallocates and frees an array of BBox structure.			     M
*                                                                            *
* PARAMETERS:                                                                M
*   BBoxArray:    To be deallocated.                                         M
*   Size:         Of the deallocated array.                                  M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdBBoxArrayFree, free                                                  M
*****************************************************************************/
void CagdBBoxArrayFree(CagdBBoxStruct *BBoxArray, int Size)
{
    int i;

    for (i = 0; i < Size; i++)
	AttrFreeAttributes(&BBoxArray[i].Attr);

    IritFree((VoidPtr) BBoxArray);
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Deallocates and frees all slots of a polyline structure.		     M
*                                                                            *
* PARAMETERS:                                                                M
*   Poly:       To be deallocated.                                           M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdPolylineFree, free                                                   M
*****************************************************************************/
void CagdPolylineFree(CagdPolylineStruct *Poly)
{
    if (Poly == NULL)
	return;

    IritFree((VoidPtr) Poly -> Polyline);
    AttrFreeAttributes(&Poly -> Attr);
    IritFree((VoidPtr) Poly);
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Deallocates and frees a polyline structure list:			     M
*                                                                            *
* PARAMETERS:                                                                M
*   PolyList:  To be deallocated.                                            M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdPolylineFreeList, free                                               M
*****************************************************************************/
void CagdPolylineFreeList(CagdPolylineStruct *PolyList)
{
    CagdPolylineStruct *PolyTemp;

    while (PolyList) {
	PolyTemp = PolyList -> Pnext;
	CagdPolylineFree(PolyList);
	PolyList = PolyTemp;
    }
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Deallocates and frees all slots of a polygon structure.	             M
*                                                                            *
* PARAMETERS:                                                                M
*   Poly:       To be deallocated.                                           M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdPolygonFree, free                                                    M
*****************************************************************************/
void CagdPolygonFree(CagdPolygonStruct *Poly)
{
    if (Poly == NULL)
	return;

    AttrFreeAttributes(&Poly -> Attr);
    IritFree((VoidPtr) Poly);
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Deallocates and frees a polygon structure list:			     M
*                                                                            *
* PARAMETERS:                                                                M
*   PolyList:  To be deallocated.                                            M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdPolygonFreeList, free                                                M
*****************************************************************************/
void CagdPolygonFreeList(CagdPolygonStruct *PolyList)
{
    CagdPolygonStruct *PolyTemp;

    while (PolyList) {
	PolyTemp = PolyList -> Pnext;
	CagdPolygonFree(PolyList);
	PolyList = PolyTemp;
    }
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Reverses a list of cagd library objects, in place.                         M
*                                                                            *
* PARAMETERS:                                                                M
*   List:       To be reversed.                                              M
*                                                                            *
* RETURN VALUE:                                                              M
*   VoidPtr:    Reversed list.                                               M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdListReverse, reverse                                                 M
*****************************************************************************/
VoidPtr CagdListReverse(VoidPtr List)
{
    CagdGenericStruct
	*OldHead = (CagdGenericStruct *) List,
	*NewHead = NULL;

    while (OldHead) {
	CagdGenericStruct
	    *TmpStruct = OldHead -> Pnext;

	OldHead -> Pnext = NewHead;
	NewHead = OldHead;

	OldHead = TmpStruct;
    }

    return (VoidPtr) NewHead;
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Returns the last element of given list of cagd library objects.            M
*                                                                            *
* PARAMETERS:                                                                M
*   List:       To return its last element,                                  M
*                                                                            *
* RETURN VALUE:                                                              M
*   VoidPtr:    Last element.                                                M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdListLast		                                             M
*****************************************************************************/
VoidPtr CagdListLast(VoidPtr List)
{
    CagdGenericStruct
	*Head = (CagdGenericStruct *) List;

    if (Head == NULL)
	return NULL;

    for ( ; Head -> Pnext != NULL; Head = Head -> Pnext);

    return (VoidPtr) Head;
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Computes the length of a list.                                             M
*                                                                            *
* PARAMETERS:                                                                M
*   List:          List of cagd objects.                                     M
*                                                                            *
* RETURN VALUE:                                                              M
*   int:           Length of list.                                           M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdListLength                                                           M
*****************************************************************************/
int CagdListLength(VoidPtr List)
{
    CagdGenericStruct
	*Head = (CagdGenericStruct *) List;
    int i;

    for (i = 0; Head != NULL; Head = Head -> Pnext, i++);

    return i;
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Applies an affine transform, in place, to given curve Crv as specified by  M
* Translate and Scale.							     M
*   Each control point is first translated by Translate and then scaled by   M
* Scale.		                                                     M
*                                                                            *
* PARAMETERS:                                                                M
*   Crv:         To be affinely transformed.                                 M
*   Translate:   Translation amount.                                         M
*   Scale:       Scaling amount.                                             M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdCrvTransform, scaling, translation, transformations                  M
*****************************************************************************/
void CagdCrvTransform(CagdCrvStruct *Crv,
		      CagdRType *Translate,
		      CagdRType Scale)
{
    switch (Crv -> GType) {
	case CAGD_CBEZIER_TYPE:
	case CAGD_CBSPLINE_TYPE:
    	    CagdTransform(Crv -> Points,
			  Crv -> Length,
    			  CAGD_NUM_OF_PT_COORD(Crv -> PType),
    			  !CAGD_IS_RATIONAL_CRV(Crv),
			  Translate,
			  Scale);

	    break;
	case CAGD_CPOWER_TYPE:
	    CAGD_FATAL_ERROR(CAGD_ERR_POWER_NO_SUPPORT);
	    break;
	default:
	    CAGD_FATAL_ERROR(CAGD_ERR_UNDEF_CRV);
	    break;
    }
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Applies an affine transform, in place, to given surface Srf as specified   M
* by Translate and Scale.						     M
*   Each control point is first translated by Translate and then scaled by   M
* Scale.		                                                     M
*                                                                            *
* PARAMETERS:                                                                M
*   Crv:         To be affinely transformed.                                 M
*   Translate:   Translation amount.                                         M
*   Scale:       Scaling amount.                                             M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdSrfTransform, scaling, translation, transformations                  M
*****************************************************************************/
void CagdSrfTransform(CagdSrfStruct *Srf,
		      CagdRType *Translate,
		      CagdRType Scale)
{
    switch (Srf -> GType) {
	case CAGD_SBEZIER_TYPE:
	case CAGD_SBSPLINE_TYPE:
	    CagdTransform(Srf -> Points,
	    		  Srf -> ULength * Srf -> VLength,
	                  CAGD_NUM_OF_PT_COORD(Srf -> PType),
			  !CAGD_IS_RATIONAL_SRF(Srf),
		          Translate,
        	          Scale);
	    break;
	case CAGD_SPOWER_TYPE:
	    CAGD_FATAL_ERROR(CAGD_ERR_POWER_NO_SUPPORT);
	    break;
	default:
	    CAGD_FATAL_ERROR(CAGD_ERR_UNDEF_SRF);
	    break;
    }
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Applies an affine transform, in place, to given set of points Points which M
* as array of vectors, each vector of length Len.                            M
*   Array Points optionally contains (if !IsNotRational) in Points[0] the    M
* weights coefficients and in Points[i] the coefficients of axis i, up to    M
* and include MaxCoord (X = 1, Y = 2, etc.).				     M
* Points are translated and scaled as prescribed by Translate and Scale.     M
*   Each control point is first translated by Translate and then scaled by   M
* Scale.		                                                     M
*                                                                            *
* PARAMETERS:                                                                M
*   Points:         To be affinely transformed. Array of vectors.            M
*   Len:            Of vectors of Points.                                    M
*   MaxCoord:       Maximum number of coordinates to be found in Points.     M
*   IsNotRational:  Do we have weights as vector Points[0]?                  M
*   Translate:      Translation amount.                                      M
*   Scale:          Scaling amount.                                          M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdTransform, scaling, translation, transformations                     M
*****************************************************************************/
void CagdTransform(CagdRType **Points,
		   int Len,
		   int MaxCoord,
		   CagdBType IsNotRational,
		   CagdRType *Translate,
		   CagdRType Scale)
{
    int i, j;

    if (IsNotRational)
	for (i = 1; i <= MaxCoord; i++)
	    for (j = 0; j < Len; j++)
		Points[i][j] = (Points[i][j] + Translate[i - 1]) * Scale;
    else
	for (i = 1; i <= MaxCoord; i++)
	    for (j = 0; j < Len; j++)
		Points[i][j] = (Points[i][j] +
				Translate[i - 1] * Points[W][j]) * Scale;
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Applies an homogeneous transformation, in place, to the given curve Crv as M
* specified by homogeneous transformation Mat.				     M
*                                                                            *
* PARAMETERS:                                                                M
*   Crv:       To be transformed.                                            M
*   Mat:       Defining the transformation.                                  M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdCrvMatTransform, scaling, rotation, translation, transformations     M
*****************************************************************************/
void CagdCrvMatTransform(CagdCrvStruct *Crv, CagdMType Mat)
{
    switch (Crv -> GType) {
	case CAGD_CBEZIER_TYPE:
	case CAGD_CBSPLINE_TYPE:
	    switch (Crv -> PType) {               /* Make sure input is 3D. */
		case CAGD_PT_E2_TYPE:
		case CAGD_PT_P2_TYPE:
		    {
			int i,
			    Len = Crv -> Length;

			Crv -> Points[3] =
			    (CagdRType *) IritMalloc(sizeof(CagdRType) * Len);

			for (i = 0; i < Len; i++)
			    Crv -> Points[3][i] = 0.0;
			Crv -> PType = (Crv -> PType == CAGD_PT_E2_TYPE ?
					CAGD_PT_E3_TYPE : CAGD_PT_P3_TYPE);
			break;
		    }
		case CAGD_PT_E3_TYPE:
		case CAGD_PT_P3_TYPE:
		    break;
		default:
		    CAGD_FATAL_ERROR(CAGD_ERR_ONLY_2D_OR_3D);
		    return;
	    }

	    CagdMatTransform(Crv -> Points,
    			     Crv -> Length,
                	     CAGD_NUM_OF_PT_COORD(Crv -> PType),
			     !CAGD_IS_RATIONAL_CRV(Crv),
		             Mat);
	    break;
	case CAGD_CPOWER_TYPE:
	    CAGD_FATAL_ERROR(CAGD_ERR_POWER_NO_SUPPORT);
	    break;
	default:
	    CAGD_FATAL_ERROR(CAGD_ERR_UNDEF_CRV);
	    break;
    }
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Applies an homogeneous transformation, in place, to the given surface Srf  M
* as specified by homogeneous transformation Mat.			     M
*                                                                            *
* PARAMETERS:                                                                M
*   Srf:       To be transformed.                                            M
*   Mat:       Defining the transformation.                                  M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdSrfMatTransform, scaling, rotation, translation, transformations     M
*****************************************************************************/
void CagdSrfMatTransform(CagdSrfStruct *Srf, CagdMType Mat)
{
    switch (Srf -> GType) {
	case CAGD_SBEZIER_TYPE:
	case CAGD_SBSPLINE_TYPE:
	    switch (Srf -> PType) {               /* Make sure input is 3D. */
		case CAGD_PT_E2_TYPE:
		case CAGD_PT_P2_TYPE:
		    {
			int i,
			Len = Srf -> ULength * Srf ->VLength;

			Srf -> Points[3] =
			    (CagdRType *) IritMalloc(sizeof(CagdRType) * Len);

			for (i = 0; i < Len; i++)
			    Srf -> Points[3][i] = 0.0;
			Srf -> PType = (Srf -> PType == CAGD_PT_E2_TYPE ?
					CAGD_PT_E3_TYPE : CAGD_PT_P3_TYPE);
			break;
		    }
		case CAGD_PT_E3_TYPE:
		case CAGD_PT_P3_TYPE:
		    break;
		default:
		    CAGD_FATAL_ERROR(CAGD_ERR_ONLY_2D_OR_3D);
		    return;
	    }
	    CagdMatTransform(Srf -> Points,
    			     Srf -> ULength * Srf -> VLength,
        	             CAGD_NUM_OF_PT_COORD(Srf -> PType),
			     !CAGD_IS_RATIONAL_SRF(Srf),
		             Mat);
	    break;
	case CAGD_SPOWER_TYPE:
	    CAGD_FATAL_ERROR(CAGD_ERR_POWER_NO_SUPPORT);
	    break;
	default:
	    CAGD_FATAL_ERROR(CAGD_ERR_UNDEF_SRF);
	    break;
    }
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Applies an homogeneous transformation, in place, to given set of points    M
* Points which as array of vectors, each vector of length Len.               M
*   Array Points optionally contains (if !IsNotRational) in Points[0] the    M
* weights coefficients and in Points[i] the coefficients of axis i, up to    M
* and include MaxCoord (X = 1, Y = 2, etc.).				     M
*                                                                            *
* PARAMETERS:                                                                M
*   Points:         To be affinely transformed. Array of vectors.            M
*   Len:            Of vectors of Points.                                    M
*   MaxCoord:       Maximum number of coordinates to be found in Points.     M
*   IsNotRational:  Do we have weights as vector Points[0]?                  M
*   Mat:       Defining the transformation.                                  M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdMatTransform, scaling, rotation, translation, transformations        M
*****************************************************************************/
void CagdMatTransform(CagdRType **Points,
		      int Len,
		      int MaxCoord,
		      CagdBType IsNotRational,
		      CagdMType Mat)
{
    int i, j;
    CagdRType P[4], Q[4];

    if (MaxCoord > 3)
	MaxCoord = 3;

    if (IsNotRational)
	for (i = 0; i < Len; i++) {
	    for (j = 1; j <= MaxCoord; j++)
		P[j - 1] = Points[j][i];

	    /* Zero unused coords. */
	    for (j = MaxCoord + 1; j < 3; i++)
		P[j - 1] = 0.0;

            MatMultVecby4by4(Q, P, Mat);

	    for (j = 1; j <= MaxCoord; j++)
		Points[j][i] = Q[j - 1];
        }
    else
	for (i = 0; i < Len; i++) {
	    for (j = 1; j <= MaxCoord; j++)
		P[j - 1] = Points[j][i];
	    P[3] = Points[W][i];

	    /* Zero unused coords. */
	    for (j = MaxCoord + 1; j < 3; i++)
		P[j - 1] = 0.0;

            MatMultWVecby4by4(Q, P, Mat);

	    for (j = 1; j <= MaxCoord; j++)
		Points[j][i] = Q[j - 1];
	    Points[W][i] = Q[3];
        }
}

/*****************************************************************************
* DESCRIPTION:                                                               *
* Routine to create one triangular polygon, given its vertices.		     *
* Returns NULL if Triangle is degenerated.				     *
*                                                                            *
* PARAMETERS:                                                                *
*   ComputeNormals:   If TRUE then use Nl? parameters. Nl? are valid.        *
*   ComputeUV:        If TRUE then use UV? parameters. UV? are valid.        *
*   Pt1, Pt2, Pt3:    Euclidean locations of vertices.                       *
*   Nl1, Nl2, Nl3:    Optional Normals of vertices (if ComputeNormals).      *
*   UV1, UV2, UV3:    Optional UV parametric location of vertices (if        *
*                     ComputeUV).                                            *
*                                                                            *
* RETURN VALUE:                                                              *
*   CagdPolygonStruct *:  A polygonal triangle structure, or NULL if points  *
*                         are colinear.                                      *
*                                                                            *
* KEYWORDS:                                                                  *
*   _CagdMakePolygon                                                         *
*****************************************************************************/
CagdPolygonStruct *_CagdMakePolygon(CagdBType ComputeNormals,
				    CagdBType ComputeUV,
				    CagdPtStruct *Pt1,
				    CagdPtStruct *Pt2,
				    CagdPtStruct *Pt3,
				    CagdVecStruct *Nl1,
				    CagdVecStruct *Nl2,
				    CagdVecStruct *Nl3,
				    CagdUVStruct *UV1,
				    CagdUVStruct *UV2,
				    CagdUVStruct *UV3)
{
    CagdPolygonStruct *Poly;

    if (GMColinear3Pts(Pt1 -> Pt, Pt2 -> Pt, Pt3 -> Pt))
	return NULL;

    Poly = CagdPolygonNew();

    PT_COPY(Poly -> Polygon[0].Pt, Pt1 -> Pt);
    PT_COPY(Poly -> Polygon[1].Pt, Pt2 -> Pt);
    PT_COPY(Poly -> Polygon[2].Pt, Pt3 -> Pt);

    if (ComputeNormals) {
	PT_COPY(Poly -> Polygon[0].Nrml, Nl1 -> Vec);
	PT_COPY(Poly -> Polygon[1].Nrml, Nl2 -> Vec);
	PT_COPY(Poly -> Polygon[2].Nrml, Nl3 -> Vec);
    }
    else {
	PT_RESET(Poly -> Polygon[0].Nrml);
	PT_RESET(Poly -> Polygon[1].Nrml);
	PT_RESET(Poly -> Polygon[2].Nrml);
    }

    if (ComputeUV) {
	UV_COPY(Poly -> Polygon[0].UV, UV1 -> UV);
	UV_COPY(Poly -> Polygon[1].UV, UV2 -> UV);
	UV_COPY(Poly -> Polygon[2].UV, UV3 -> UV);
    }
    else {
	UV_RESET(Poly -> Polygon[0].UV);
	UV_RESET(Poly -> Polygon[1].UV);
	UV_RESET(Poly -> Polygon[2].UV);
    }

    return Poly;
}

/*****************************************************************************
* DESCRIPTION:                                                               M
* Sets the way (co)linear surfaces are converted into polygons.		     M
*                                                                            *
* PARAMETERS:                                                                M
*   Lin2Poly:  Specification.                                                M
*                                                                            *
* RETURN VALUE:                                                              M
*   void                                                                     M
*                                                                            *
* KEYWORDS:                                                                  M
*   CagdSetLinear2Poly, polygonization, polygonal approximation              M
*****************************************************************************/
void CagdSetLinear2Poly(CagdLin2PolyType Lin2Poly)
{
    _CagdLin2Poly = Lin2Poly;
}
