SFX2VTK.CPP

Go to the documentation of this file.

/* --
OpenFX version 1.0 - Modelling, Animation and Rendering Package
Copyright (C) 2000 OpenFX Development Team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

You may contact the OpenFX development team via elecronic mail
at core@openfx.org, or visit our website at http://openfx.org for
further information and support details.
-- */

//  SFX2VTK.CPP

SfxBound::SfxBound(){}

SfxBound::~SfxBound(){}

double SfxBound::GetMaximumSize(void){
 double s,sx,sy,sz,x,y,z;
 long i;
 double xmin,ymin,zmin,xmax,ymax,zmax;
 xmin = ymin = zmin =  1.e30;
 xmax = ymax = zmax = -1.e30;
 s = sx = sy = sz = 1.0;
 for(i=0;i<Nvert;i++){
   if((MainVp+i)->status == SELECTED){
     x = (float)((MainVp+i)->xyz[0])/((float)UNIT);
     y = (float)((MainVp+i)->xyz[1])/((float)UNIT);
     z = (float)((MainVp+i)->xyz[2])/((float)UNIT);
     if(x < xmin)xmin=x;
     if(y < ymin)ymin=y;
     if(z < zmin)zmin=z;
     if(x > xmax)xmax=x;
     if(y > ymax)ymax=y;
     if(z > zmax)zmax=z;
   }
 }
 sx = fabs(xmax - xmin);
 sy = fabs(ymax - ymin);
 sz = fabs(zmax - zmin);
 if(sx > s)s=sx;
 if(sy > s)s=sy;
 if(sz > s)s=sz;
 return s;
}

SfxReader::SfxReader()
{
 Nv=Ne=Nf=0;
 scale=1.0;
}

SfxReader::~SfxReader()
{
}

int SfxReader::GetNumberOfVertices(void){return (int)this->Nv;}
int SfxReader::GetNumberOfEdge(void){return (int)this->Ne;}
int SfxReader::GetNumberOfFaces(void){return (int)this->Nf;}
void SfxReader::SetScale(double s){this->scale=s;}

void SfxReader::Execute()
{
  float x[3];
  int i,pts[3],count;
  vtkFloatPoints *newPoints;
  vtkCellArray *newTris;
  vtkPolyData *output = this->GetOutput();
  vtkIntScalars *vdata;
  if(NvertSelect == 0)return;
  newPoints = new vtkFloatPoints(NvertSelect);
  vdata     = new vtkIntScalars(NvertSelect);
  for(count=0,i=0;i<Nvert;i++){
    if((MainVp+i)->status == SELECTED){
      x[0] = (float)((MainVp+i)->xyz[0])*scale/((float)UNIT);
      x[1] = (float)((MainVp+i)->xyz[1])*scale/((float)UNIT);
      x[2] = (float)((MainVp+i)->xyz[2])*scale/((float)UNIT);
      (MainVp+i)->id=count++;
      newPoints->InsertNextPoint(x);
      vdata->InsertNextScalar(i);
      this->Nv++;
    }
  }
  face *fp;
  for(i=0,count=0;i<Nface;i++){
    fp=(MainFp+i);
    if((MainVp+fp->V[0])->status == SELECTED &&
       (MainVp+fp->V[1])->status == SELECTED &&
       (MainVp+fp->V[2])->status == SELECTED)count++;
  }
  newTris = new vtkCellArray;
  newTris->Allocate(count);
  for(i=0;i<Nface;i++){
    fp=(MainFp+i);
    if((MainVp+fp->V[0])->status == SELECTED &&
       (MainVp+fp->V[1])->status == SELECTED &&
       (MainVp+fp->V[2])->status == SELECTED){
      pts[0] = (int)((MainVp+fp->V[0])->id);
      pts[1] = (int)((MainVp+fp->V[1])->id);
      pts[2] = (int)((MainVp+fp->V[2])->id);
      newTris->InsertNextCell(3,pts);
      this->Nf++;
    }
  }
  output->SetPoints(newPoints);
  newPoints->Delete();
  output->SetPolys(newTris);
  newTris->Delete();
  output->GetPointData()->SetScalars(vdata);
  vdata->Delete();
  output->Squeeze();
//MessageBox(NULL,"SfxReader Finished",NULL,MB_OK);
}

SfxPointReader::SfxPointReader()
{
 Nv=0;
 scale=1.0;
}

SfxPointReader::~SfxPointReader()
{
}

void SfxPointReader::SetScale(double s){this->scale=s;}

void SfxPointReader::Execute()
{
  float x[3];
  int i,pts[2],count;
  vtkFloatPoints *newPoints;
  vtkCellArray *newTris;
  vtkPolyData *output = this->GetOutput();
  vtkIntScalars *vdata;
  if(NvertSelect == 0)return;
  newPoints = new vtkFloatPoints(NvertSelect);
  vdata     = new vtkIntScalars(NvertSelect);
  for(count=0,i=0;i<Nvert;i++){
    if((MainVp+i)->status == SELECTED){
      x[0] = (float)((MainVp+i)->xyz[0])*scale/((float)UNIT);
      x[1] = (float)((MainVp+i)->xyz[1])*scale/((float)UNIT);
      x[2] = (float)((MainVp+i)->xyz[2])*scale/((float)UNIT);
      (MainVp+i)->id=count++;
      newPoints->InsertNextPoint(x);
      vdata->InsertNextScalar(i);
      this->Nv++;
    }
  }
  newTris = new vtkCellArray;
  newTris->Allocate(count);
  for(i=0;i<Nvert;i++){
    if((MainVp+i)->status == SELECTED){
      pts[0] = (int)((MainVp+i)->id);
      newTris->InsertNextCell(1);
      newTris->InsertCellPoint(pts[0]);
    }
  }
  output->SetPoints(newPoints);
  newPoints->Delete();
  output->SetVerts(newTris);
  newTris->Delete();
  output->GetPointData()->SetScalars(vdata);
  vdata->Delete();
  output->Squeeze();
}


SfxEdgeReader::SfxEdgeReader()
{
 Nv=0; Ne=0;
 scale=1.0;
}

SfxEdgeReader::~SfxEdgeReader()
{
}

void SfxEdgeReader::SetScale(double s){this->scale=s;}

void SfxEdgeReader::Execute()
{
  float x[3];
  int i,pts[2],count;
  vtkFloatPoints *newPoints;
  vtkCellArray *newTris;
  vtkPolyData *output = this->GetOutput();
  vtkIntScalars *vdata;
  if(NvertSelect == 0)return;
  newPoints = new vtkFloatPoints(NvertSelect);
  vdata     = new vtkIntScalars(NvertSelect);
  for(count=0,i=0;i<Nvert;i++){
    if((MainVp+i)->status == SELECTED){
      x[0] = (float)((MainVp+i)->xyz[0])*scale/((float)UNIT);
      x[1] = (float)((MainVp+i)->xyz[1])*scale/((float)UNIT);
      x[2] = (float)((MainVp+i)->xyz[2])*scale/((float)UNIT);
      (MainVp+i)->id=count++;
      newPoints->InsertNextPoint(x);
      vdata->InsertNextScalar(i);
      this->Nv++;
    }
  }
  edge *ep;
  for(i=0,count=0,ep=MainEp;i<Nedge;i++){
    if((MainVp+ep->V[0])->status == SELECTED &&
       (MainVp+ep->V[1])->status == SELECTED)count++;
    ep++;
  }
  newTris = new vtkCellArray;
  newTris->Allocate(count);
  for(i=0,ep=MainEp;i<Nedge;i++){
    if((MainVp+ep->V[0])->status == SELECTED &&
       (MainVp+ep->V[1])->status == SELECTED){
      pts[0] = (int)((MainVp+ep->V[0])->id);
      pts[1] = (int)((MainVp+ep->V[1])->id);
      newTris->InsertNextCell(2,pts);
      this->Ne++;
    }
    ep++;
  }
  output->SetPoints(newPoints);
  newPoints->Delete();
  output->SetPolys(newTris);
  newTris->Delete();
  output->GetPointData()->SetScalars(vdata);
  vdata->Delete();
  output->Squeeze();
}

SfxBaseWriter::SfxBaseWriter()
{
  this->Input = NULL;
}

void SfxBaseWriter::Write()
{
  if ( !this->Input ) {
    return;
  }
  this->Input->Update();
  this->WriteData();
  this->Input->ReleaseData();
}

void SfxBaseWriter::Update()
{
  this->Write();
}

SfxWriter::SfxWriter()
{
 Nv=0; Ne=0; Nf=0;
 scale=1.0;
}

SfxWriter::~SfxWriter()
{
}

void SfxWriter::SetScale(double s){this->scale=s;}
int SfxWriter::GetNumberOfVertices(void){return (int)this->Nv;}
int SfxWriter::GetNumberOfEdge(void){return (int)this->Ne;}
int SfxWriter::GetNumberOfFaces(void){return (int)this->Nf;}

void SfxWriter::SetInput(vtkPolyData *input)
{
  if ( this->Input != input )
    {
    this->Input = (vtkDataSet *) input;
    this->Modified();
    }
}

void SfxWriter::WriteData()
{
  vtkPoints *pts;
  vtkCellArray *polys;
  vtkPolyData *input=(vtkPolyData *)this->Input;

  if ( (pts = input->GetPoints()) == NULL ||
  (polys = input->GetPolys()) == NULL ){
    return;
  }
  vertex *Vp;
  face   *Fp;
  float p[3];
  int i,npts,npolys;
  long BaseVert;
  BaseVert=Nvert;
  npts=input->GetNumberOfPoints();
  npolys=input->GetNumberOfPolys();
  this->Nv=npts;
  this->Nf=npolys;
  if(npts > 0){
    if(!UpdateVertexHeap(Nvert+npts))return;
    for(i=0;i<npts;i++){
      pts->GetPoint(i,p);
      CreateVertex();
      Vp=(MainVp+Nvert-1);
      Vp->id=0;
      Vp->sp=NULL;
      Vp->xyz[0]=(long)(p[0]*(float)UNIT*scale);
      Vp->xyz[1]=(long)(p[1]*(float)UNIT*scale);
      Vp->xyz[2]=(long)(p[2]*(float)UNIT*scale);
    }
  }
  if(npolys > 0){
    int *indx;
    if(!UpdateFaceHeap(Nface+npolys))return;
    for (polys->InitTraversal(); polys->GetNextCell(npts,indx); ){
      CreateFace(BaseVert+(long)indx[0],
                 BaseVert+(long)indx[1],
                 BaseVert+(long)indx[2]);
      this->InsertInVertexList(BaseVert,indx[0],indx[1]);
      this->InsertInVertexList(BaseVert,indx[1],indx[2]);
      this->InsertInVertexList(BaseVert,indx[2],indx[0]);
    }
    this->BuildEdges(BaseVert);
  }
}

// Use the vertex's skeleton pointer and integer identifer as temporary
// storage for build edge adjacency lists since they are not uses on new
// vertices.
//
void SfxWriter::InsertInVertexList(long base, long Vj, long Vi){
 vertex *vj,*vi;
 long *list,i,j;
 vj=(MainVp+base+Vj);
 vi=(MainVp+base+Vi);
 list = (long *)vi->sp;
 if(vi->id > 0)for(i=0;i<vi->id;i++)if(list[i] == Vj)return;
 list = (long *)vj->sp;
 if(vj->id > 0)for(j=0;j<vj->id;j++)if(list[j] == Vi)return;
 if(vi->id == 0){
   if((list = (long *)X__Malloc((vi->id + 1)*sizeof(long))) == NULL){
     return;
   }
   vi->sp=(struct Designer_SKELETON_tag *)list;
 }
 else{
   list = (long *)vi->sp;
   if((list = (long *)X__Realloc(list,(vi->id + 1)*sizeof(long))) == NULL){
     return;
   }
   vi->sp=(struct Designer_SKELETON_tag *)list;
 }
 list[vi->id] = base+Vj;
 (vi->id)++;
}

void SfxWriter::BuildEdges(long base){
 long n,j,i,*list;
 vertex *vp;
 vp=(MainVp+base);
 for(j=base;j<Nvert;j++){
   if(vp->id != 0 && vp->sp != NULL){
     if(!UpdateEdgeHeap(Nedge+vp->id))return;
     list = (long *)vp->sp;
     for(i=0;i<vp->id;i++)CreateEdge(j,list[i]);
     X__Free(vp->sp); vp->sp=NULL; vp->id=0;
   }
   vp++;
 }
}

void SfxWriter::EraseOldStructure(long base){
 long c;
 vertex *vp;
 vp=(MainVp+base); for(c=base;c<Nvert;c++){
   if(vp->status == SELECTED){
     vp->status=INEDITOR; NvertSelect--; NvertDeselect++;
   }
   vp++;
 }
 EraseVertex(1);
 vp=MainVp; for(c=0;c<Nvert;c++){
   if(vp->status == INEDITOR){
     vp->status=SELECTED; NvertSelect++; NvertDeselect--;
   }
   vp++;
 }
}

void SfxWriter::OffsetStructure(long base, long dx, long dy, long dz){
 long c;
 vertex *vp;
 vp=(MainVp+base); for(c=base;c<Nvert;c++){
   vp->xyz[0] += dx;
   vp->xyz[1] += dy;
   vp->xyz[2] += dz;
   vp++;
 }
}