DECIMATE.CPP

Go to the documentation of this file.

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

/*  DECIMATE.CPP  */

#include "vtk.hh"
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <windows.h>

#define UNIT         32768L
#define DESELECTED       0
#define SELECTED         1
#define INEDITOR         6

#ifdef __cplusplus
extern "C" {
#endif

#include "struct.h"
#include "dstruct.h"

#ifdef __cplusplus
}
#endif

#include "decimate.h"

static long ColourToLong(unsigned char *c);

static void LongToColour(long id, unsigned char *c);

class SfxReader : public vtkPolySource
{
public:
  SfxReader();
  ~SfxReader();
  char *GetClassName() {return "SfxReader";};
  int GetNumberOfVertices(void);
  int GetNumberOfEdge(void);
  int GetNumberOfFaces(void);

protected:
  void Execute();
  int  Nv,Nf,Ne;
};

class SfxBaseWriter : public vtkObject
{
public:
  SfxBaseWriter();
  virtual void Write();
  void Update();

protected:
  vtkDataSet *Input;
  virtual void WriteData() = 0;
};

class SfxWriter : public SfxBaseWriter
{
public:
  SfxWriter();
  ~SfxWriter();
  char *GetClassName() {return "SfxWriter";};
  void SetInput(vtkPolyData *input);
  void SetInput(vtkPolyData &input) {this->SetInput(&input);};
  vtkPolyData *GetInput() {return (vtkPolyData *)this->Input;};
  int GetNumberOfVertices(void);
  int GetNumberOfEdge(void);
  int GetNumberOfFaces(void);
  void EraseOldStructure(long );
  void OffsetStructure(long , long , long , long );

protected:
  int Nv,Ne,Nf;
  void WriteData();
  void InsertInVertexList(long , long , long );
  void BuildEdges(long );
};

static HWND      hParent;
static HINSTANCE hThisInstance;

static BOOL CALLBACK SimplifyDlgProc(HWND hwnd, UINT msg,
                             WPARAM wparam, LPARAM lparam);

#if __WATCOMC__
int APIENTRY LibMain(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved){
#else
BOOL WINAPI DllMain(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved){
#endif
  switch (dwReason) {
    case DLL_PROCESS_ATTACH: {
      hThisInstance=(HINSTANCE)hDLL;
      if(hDLL == NULL)MessageBeep(MB_OK);
      break;
    }
    case DLL_PROCESS_DETACH:
      break;
  }
  return TRUE;
}


extern "C" BOOL _Xmodeler
 (HWND parent_window,HWND info_window,X__STRUCTURE *lpevi){
 HCURSOR hSave;
 static struct bp {
   double TargetReduction;
   long   MaximumIterations,MaximumSubIterations;
   double InitialError,ErrorIncrement,
          AspectRatio,InitialFeatureAngle;
 } d;
 lpEVI=lpevi;
 hParent=parent_window;
 d.TargetReduction=0.9;
 d.MaximumIterations=10;
 d.MaximumSubIterations=2;
 d.InitialError=0.0000;
 d.ErrorIncrement=0.002;  //  0.0002
 d.AspectRatio=20.0;
 d.InitialFeatureAngle=60.0;
 if(DialogBoxParam(hThisInstance,MAKEINTRESOURCE(DLG_SIM),hParent,
             (DLGPROC)SimplifyDlgProc,(LPARAM)&d) == FALSE)return FALSE;
 hSave=SetCursor(LoadCursor(NULL,IDC_WAIT));
 {
  char message[256];
  int Nv1,Nf1,Nv2,Nf2;
  SfxReader sfxinput;
  SfxWriter sfxoutput;
  vtkDecimate deci;
  sfxinput.Update();
  Nv1=sfxinput.GetNumberOfVertices();
  Nf1=sfxinput.GetNumberOfFaces();
  deci.SetInput(sfxinput.GetOutput());
  deci.SetTargetReduction((float)d.TargetReduction);
  deci.SetMaximumIterations(d.MaximumIterations);
  deci.SetMaximumSubIterations(d.MaximumSubIterations);
  deci.SetInitialError((float)d.InitialError);
  deci.SetErrorIncrement((float)d.ErrorIncrement);
  deci.SetAspectRatio((float)d.AspectRatio);
  deci.SetInitialFeatureAngle((float)d.InitialFeatureAngle);
  sfxoutput.SetInput(deci.GetOutput());
  sfxoutput.Write();
  Nv2=sfxoutput.GetNumberOfVertices();
  Nf2=sfxoutput.GetNumberOfFaces();
  sprintf(message,"Decimated %ld Vertices %ld Faces\n to %ld Vertices %ld Faces",
          Nv1,Nf1,Nv2,Nf2);
  MessageBox(parent_window,message,"Decimate",MB_OK);
 }
 SetCursor(hSave);
 return TRUE;
}

static BOOL CALLBACK SimplifyDlgProc(HWND hwnd, UINT msg,
                             WPARAM wparam, LPARAM lparam){
 BOOL err;
 double f;
 int i;
 static struct bp {
   double TargetReduction;
   long   MaximumIterations,MaximumSubIterations;
   double InitialError,ErrorIncrement,
          AspectRatio,InitialFeatureAngle;
 } *dp;
 char str[32];
 switch( msg ) {
   case WM_INITDIALOG:
     dp=(struct bp *)lparam;
     SetDlgItemInt(hwnd,DLG_SIM_MAXIMUMITERATIONS,dp->MaximumIterations,FALSE);
     SetDlgItemInt(hwnd,DLG_SIM_MAXIMUMSUBITERATIONS,dp->MaximumSubIterations,FALSE);
     sprintf(str,"%.1lf",dp->TargetReduction*100.0);
     SetDlgItemText(hwnd,DLG_SIM_TARGETREDUCTION,(LPCTSTR)str);
     sprintf(str,"%.4lf",dp->InitialError);
     SetDlgItemText(hwnd,DLG_SIM_INITIALERROR,(LPCTSTR)str);
     sprintf(str,"%.4lf",dp->ErrorIncrement);
     SetDlgItemText(hwnd,DLG_SIM_ERRORINCREMENT,(LPCTSTR)str);
     sprintf(str,"%.2lf",dp->AspectRatio);
     SetDlgItemText(hwnd,DLG_SIM_ASPECTRATIO,(LPCTSTR)str);
     sprintf(str,"%.2lf",dp->InitialFeatureAngle);
     SetDlgItemText(hwnd,DLG_SIM_INITIALFEATUREANGLE,(LPCTSTR)str);
     CentreDlgOnS(hwnd);
     return (TRUE);
   case WM_COMMAND:
      switch(LOWORD(wparam)){
        case IDCANCEL:
          EndDialog(hwnd,FALSE);
          return(TRUE);
        case IDOK:
          if(GetDlgItemText(hwnd,DLG_SIM_TARGETREDUCTION,str,10) == 0){
            EndDialog(hwnd,FALSE); return TRUE;
          }
          dp->TargetReduction=atof(str)/100.0;
          if(GetDlgItemText(hwnd,DLG_SIM_INITIALERROR,str,10) == 0){
            EndDialog(hwnd,FALSE); return TRUE;
          }
          dp->InitialError=atof(str);
          if(GetDlgItemText(hwnd,DLG_SIM_ERRORINCREMENT,str,10) == 0){
            EndDialog(hwnd,FALSE); return TRUE;
          }
          dp->ErrorIncrement=atof(str);
          if(GetDlgItemText(hwnd,DLG_SIM_ASPECTRATIO,str,10) == 0){
            EndDialog(hwnd,FALSE); return TRUE;
          }
          dp->AspectRatio=atof(str);
          if(GetDlgItemText(hwnd,DLG_SIM_INITIALFEATUREANGLE,str,10) == 0){
            EndDialog(hwnd,FALSE); return TRUE;
          }
          dp->InitialFeatureAngle=atof(str);
          i=GetDlgItemInt(hwnd,DLG_SIM_MAXIMUMITERATIONS,&err,FALSE);
          if(err)dp->MaximumIterations=i;
          i=GetDlgItemInt(hwnd,DLG_SIM_MAXIMUMSUBITERATIONS,&err,FALSE);
          if(err)dp->MaximumSubIterations=i;
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return(FALSE);
}

long ColourToLong(unsigned char *c){
 return ((long)(c[0]) << 16) | ((long)(c[1]) << 8) | ((long)c[2]);
}

void LongToColour(long id, unsigned char *c){
 c[0] = (unsigned char)((id >> 16) & 0xff);
 c[1] = (unsigned char)((id >>  8) & 0xff);
 c[2] = (unsigned char)((id      ) & 0xff);
}

SfxReader::SfxReader()
{
 Nv=Ne=Nf=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::Execute()
{
  face *fp;
  float x[3];
  int i,pts[3],count;
  vtkFloatPoints *newPoints;
  vtkCellArray *newTris;
  vtkPolyData *output = this->GetOutput();
  vtkUserDefined *vdata;
  if(NvertSelect == 0)return;
  newPoints = new vtkFloatPoints(NvertSelect);
  vdata     = new vtkUserDefined(NvertSelect);
  // make a best guess for vertex color based on one of the faces
  // attached to that vertex
  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){
      (MainVp+fp->V[0])->id=ColourToLong(fp->color);
      (MainVp+fp->V[1])->id=ColourToLong(fp->color);
      (MainVp+fp->V[2])->id=ColourToLong(fp->color);
    }
  }
  for(count=0,i=0;i<Nvert;i++){
    if((MainVp+i)->status == SELECTED){
      x[0] = (float)((MainVp+i)->xyz[0])/((float)UNIT);
      x[1] = (float)((MainVp+i)->xyz[1])/((float)UNIT);
      x[2] = (float)((MainVp+i)->xyz[2])/((float)UNIT);
      // store the best guess at vertex colour
      vdata->InsertNextUserDefined((void *)((MainVp+i)->id));
      (MainVp+i)->id=count++;
      newPoints->InsertNextPoint(x);
      this->Nv++;
    }
  }
  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()->SetUserDefined(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;
}

SfxWriter::~SfxWriter()
{
}

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);
      Vp->xyz[1]=(long)(p[1]*(float)UNIT);
      Vp->xyz[2]=(long)(p[2]*(float)UNIT);
    }
  }
  if(npolys > 0){
    int *indx;
    if(!UpdateFaceHeap(Nface+npolys))return;
    vtkPointData *pd=input->GetPointData();
    vtkUserDefined *data=pd->GetUserDefined();
    int ns=data->GetNumberOfUserDefined();
    for (polys->InitTraversal(); polys->GetNextCell(npts,indx); ){
      CreateFace(BaseVert+(long)indx[0],
                 BaseVert+(long)indx[1],
                 BaseVert+(long)indx[2]);
      // get the user defined for the vertex that remains after
      // decimations
      long c = (long)data->GetUserDefined(indx[0]);
      // set the face based on the data from one of its vertices
      unsigned char fc[3];
      LongToColour(c,fc);
      for(i=0;i<3;i++)(MainFp+Nface-1)->color[i]=fc[i];
//RSFx may need to be changed to account for new face structure
      this->InsertInVertexList(BaseVert,indx[0],indx[1]);
      this->InsertInVertexList(BaseVert,indx[1],indx[2]);
      this->InsertInVertexList(BaseVert,indx[2],indx[0]);
    }
    this->BuildEdges(BaseVert);
  }


  this->EraseOldStructure(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++;
 }
}