src/glu/sgi/libnurbs/internals/dataTransform.cc

   1 /*
   2 ** License Applicability. Except to the extent portions of this file are
   3 ** made subject to an alternative license as permitted in the SGI Free
   4 ** Software License B, Version 1.1 (the "License"), the contents of this
   5 ** file are subject only to the provisions of the License. You may not use
   6 ** this file except in compliance with the License. You may obtain a copy
   7 ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
   8 ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
   9 **
  10 ** http://oss.sgi.com/projects/FreeB
  11 **
  12 ** Note that, as provided in the License, the Software is distributed on an
  13 ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
  14 ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
  15 ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
  16 ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
  17 **
  18 ** Original Code. The Original Code is: OpenGL Sample Implementation,
  19 ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
  20 ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
  21 ** Copyright in any portions created by third parties is as indicated
  22 ** elsewhere herein. All Rights Reserved.
  23 **
  24 ** Additional Notice Provisions: The application programming interfaces
  25 ** established by SGI in conjunction with the Original Code are The
  26 ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
  27 ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
  28 ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
  29 ** Window System(R) (Version 1.3), released October 19, 1998. This software
  30 ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
  31 ** published by SGI, but has not been independently verified as being
  32 ** compliant with the OpenGL(R) version 1.2.1 Specification.
  33 **
  34 ** $Date: 2001/03/17 00:25:40 $ $Revision: 1.1 $
  35 */
  36 /*
  37 ** $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libnurbs/internals/dataTransform.cc,v 1.1 2001/03/17 00:25:40 brianp Exp $
  38 */
  39
  40 #include <stdlib.h>
  41 #include <stdio.h>
  42 #include "glimports.h"
  43 #include "myassert.h"
  44 #include "nurbsconsts.h"
  45 #include "trimvertex.h"
  46 #include "dataTransform.h"
  47
  48 extern directedLine* arcLoopToDLineLoop(Arc_ptr loop);
  49
  50 static directedLine* copy_loop(Arc_ptr loop, Real2* vertArray, int& index, directedLine dline_buf[], sampledLine sline_buf[], int& index_dline)
  51 {
  52   directedLine *ret;
  53   int old_index = index;
  54   int i = index;
  55   int j;
  56   for(j=0; j<loop->pwlArc->npts-1; j++, i++)
  57     {
  58       vertArray[i][0] = loop->pwlArc->pts[j].param[0];
  59       vertArray[i][1] = loop->pwlArc->pts[j].param[1];
  60     }
  61   loop->clearmark();
  62
  63   for(Arc_ptr jarc = loop->next; jarc != loop; jarc=jarc->next)
  64     {
  65       for(j=0; j<jarc->pwlArc->npts-1; j++, i++)
  66         {
  67           vertArray[i][0] = jarc->pwlArc->pts[j].param[0];
  68           vertArray[i][1] = jarc->pwlArc->pts[j].param[1];
  69         }
  70       jarc->clearmark();
  71     }
  72   //copy the first vertex again
  73   vertArray[i][0] = loop->pwlArc->pts[0].param[0];
  74   vertArray[i][1] = loop->pwlArc->pts[0].param[1];
  75   i++;
  76   index=i;
  77
  78   directedLine* dline;
  79   sampledLine* sline;
  80   sline = &sline_buf[index_dline];
  81   dline = &dline_buf[index_dline];
  82   sline->init(2, &vertArray[old_index]);
  83   dline->init(INCREASING, sline);
  84   ret = dline;
  85   index_dline++;
  86
  87   for(i=old_index+1; i<= index-2; i++)
  88     {
  89       sline = &sline_buf[index_dline];
  90       dline = &dline_buf[index_dline];
  91       sline->init(2, &vertArray[i]);
  92       dline->init(INCREASING, sline);
  93       ret->insert(dline);
  94       index_dline++;
  95     }
  96   return ret;
  97 }
  98
  99 static int num_edges(Bin& bin)
 100 {
 101   int sum=0;
 102   for(Arc_ptr jarc = bin.firstarc(); jarc; jarc=bin.nextarc())
 103     sum += jarc->pwlArc->npts-1;
 104   return sum;
 105 }
 106 /*
 107 directedLine* bin_to_DLineLoops(Bin& bin)
 108 {
 109   directedLine *ret=NULL;
 110   directedLine *temp;
 111
 112   int numedges = num_edges(bin);
 113   directedLine* dline_buf = new directedLine[numedges]; //not work for N32?
 114   sampledLine* sline_buf=new sampledLine[numedges];
 115
 116   Real2* vertArray = new Real2[numedges*2];
 117   int index = 0;
 118   int index_dline = 0;
 119   bin.markall();
 120
 121   for(Arc_ptr jarc = bin.firstarc(); jarc; jarc=bin.nextarc())
 122     {
 123       if(jarc->ismarked())
 124         {
 125           assert(jarc->check() != 0);
 126           Arc_ptr jarchead = jarc;
 127           do {
 128             jarc->clearmark();
 129             jarc = jarc->next;
 130           } while(jarc != jarchead);
 131           temp=copy_loop(jarchead, vertArray, index, dline_buf, sline_buf, index_dline);
 132           ret = temp->insertPolygon(ret);
 133         }
 134     }
 135
 136   return ret;
 137 }
 138 */
 139
 140
 141 directedLine* bin_to_DLineLoops(Bin& bin)
 142 {
 143   directedLine *ret=NULL;
 144   directedLine *temp;
 145   bin.markall();
 146   for(Arc_ptr jarc=bin.firstarc(); jarc; jarc=bin.nextarc()){
 147     if(jarc->ismarked()) {
 148       assert(jarc->check() != 0);
 149       Arc_ptr jarchead = jarc;
 150       do {
 151         jarc->clearmark();
 152         jarc = jarc->next;
 153       } while(jarc != jarchead);
 154       temp =  arcLoopToDLineLoop(jarc);
 155       ret = temp->insertPolygon(ret);
 156     }
 157   }
 158   return ret;
 159 }
 160
 161 directedLine* o_pwlcurve_to_DLines(directedLine* original, O_pwlcurve* pwl)
 162 {
 163   directedLine* ret = original;
 164   for(Int i=0; i<pwl->npts-1; i++)
 165     {
 166       sampledLine* sline = new sampledLine(2);
 167       sline->setPoint(0, pwl->pts[i].param);
 168       sline->setPoint(1, pwl->pts[i+1].param);
 169       directedLine* dline = new directedLine(INCREASING, sline);
 170       if(ret == NULL)
 171         ret = dline;
 172       else
 173         ret->insert(dline);
 174     }
 175   return ret;
 176 }
 177
 178 directedLine* o_curve_to_DLineLoop(O_curve* cur)
 179 {
 180   directedLine *ret;
 181   if(cur == NULL)
 182     return NULL;
 183   assert(cur->curvetype == ct_pwlcurve);
 184   ret = o_pwlcurve_to_DLines(NULL, cur->curve.o_pwlcurve);
 185   for(O_curve* temp = cur->next; temp != NULL; temp = temp->next)
 186     {
 187       assert(temp->curvetype == ct_pwlcurve);
 188       ret = o_pwlcurve_to_DLines(ret, temp->curve.o_pwlcurve);
 189     }
 190   return ret;
 191 }
 192
 193 directedLine* o_trim_to_DLineLoops(O_trim* trim)
 194 {
 195   O_trim* temp;
 196   directedLine *ret;
 197   if(trim == NULL)
 198     return NULL;
 199   ret = o_curve_to_DLineLoop(trim->o_curve);
 200
 201   for(temp=trim->next; temp != NULL; temp = temp->next)
 202     {
 203       ret = ret->insertPolygon(o_curve_to_DLineLoop(temp->o_curve));
 204     }
 205   return ret;
 206 }