Integration of OCCT 6.5.0 from SVN

src/GeomConvert/GeomConvert_BSplineSurfaceKnotSplitting.cxx

@@ -0,0 +1,169 @@
+//File GeomConvert_BSplineSurfaceKnotSplitting.cxx
+//Jean-Claude Vauthier 28 Novembre 1991
+//Passage sur C1 Aout 1992
+
+
+#include <GeomConvert_BSplineSurfaceKnotSplitting.ixx>
+
+#include <Standard_RangeError.hxx>
+
+#include <BSplCLib.hxx>
+typedef Handle(Geom_BSplineSurface)     Handle(BSplineSurface);
+typedef TColStd_Array1OfInteger      Array1OfInteger;
+typedef TColStd_HArray1OfInteger HArray1OfInteger;
+
+
+
+
+GeomConvert_BSplineSurfaceKnotSplitting::
+GeomConvert_BSplineSurfaceKnotSplitting (
+
+const Handle(BSplineSurface)& BasisSurface, 
+const Standard_Integer        UContinuityRange,
+const Standard_Integer        VContinuityRange
+
+) {
+
+
+  if (UContinuityRange < 0 || VContinuityRange < 0) { 
+    Standard_RangeError::Raise(); 
+  }
+
+  Standard_Integer FirstUIndex = BasisSurface->FirstUKnotIndex ();
+  Standard_Integer LastUIndex  = BasisSurface->LastUKnotIndex  ();
+  Standard_Integer FirstVIndex = BasisSurface->FirstVKnotIndex ();
+  Standard_Integer LastVIndex  = BasisSurface->LastVKnotIndex  ();
+  Standard_Integer UDegree     = BasisSurface->UDegree ();
+  Standard_Integer VDegree     = BasisSurface->VDegree ();
+  Standard_Integer i;
+
+
+
+  if (UContinuityRange == 0) {
+    usplitIndexes = new HArray1OfInteger (1, 2);
+    usplitIndexes->SetValue (1, FirstUIndex);
+    usplitIndexes->SetValue (2, LastUIndex);
+  }
+  else {
+    Standard_Integer NbUKnots = BasisSurface->NbUKnots();
+    Array1OfInteger UMults (1, NbUKnots);
+    BasisSurface->UMultiplicities (UMults);
+    Standard_Integer Mmax = BSplCLib::MaxKnotMult (UMults, FirstUIndex, LastUIndex);
+    if (UDegree - Mmax >= UContinuityRange) {
+      usplitIndexes = new HArray1OfInteger (1, 2);
+      usplitIndexes->SetValue (1, FirstUIndex);
+      usplitIndexes->SetValue (2, LastUIndex);
+    }
+    else {
+      Array1OfInteger USplit (1, LastUIndex - FirstUIndex + 1);
+      Standard_Integer NbUSplit = 1;
+      Standard_Integer UIndex = FirstUIndex;
+      USplit (NbUSplit) = UIndex;
+      UIndex++;
+      NbUSplit++;
+      while (UIndex < LastUIndex) {
+        if (UDegree - UMults(UIndex) < UContinuityRange) {
+          USplit (NbUSplit) = UIndex;
+          NbUSplit++;
+        }
+        UIndex++;
+      }
+      USplit (NbUSplit) = UIndex;
+      usplitIndexes = new HArray1OfInteger (1, NbUSplit);
+      for (i = 1; i <= NbUSplit; i++) {
+        usplitIndexes->SetValue (i, USplit (i));
+      }
+    }
+  }
+
+
+
+  if (VContinuityRange == 0) {
+    vsplitIndexes = new HArray1OfInteger (1, 2);
+    vsplitIndexes->SetValue (1, FirstVIndex);
+    vsplitIndexes->SetValue (2, LastVIndex);
+  }
+  else {
+    Standard_Integer NbVKnots = BasisSurface->NbVKnots();
+    Array1OfInteger VMults (1, NbVKnots);
+    BasisSurface->VMultiplicities (VMults);
+    Standard_Integer Mmax = BSplCLib::MaxKnotMult (VMults, FirstVIndex, LastVIndex);
+    if (VDegree - Mmax >= VContinuityRange) {
+      usplitIndexes = new HArray1OfInteger (1, 2);
+      usplitIndexes->SetValue (1, FirstVIndex);
+      usplitIndexes->SetValue (2, LastVIndex);
+    }
+    else {
+      Array1OfInteger VSplit (1, LastVIndex - FirstVIndex + 1);
+      Standard_Integer NbVSplit  = 1;
+      Standard_Integer VIndex    = FirstVIndex;
+      VSplit (NbVSplit) = VIndex;
+      VIndex++;
+      NbVSplit++;
+      while (VIndex < LastVIndex) {
+        if (VDegree - VMults (VIndex) < VContinuityRange) {
+          VSplit (NbVSplit) = VIndex;
+          NbVSplit++;
+        }
+        VIndex++;
+      }
+      VSplit (NbVSplit) = VIndex;
+      vsplitIndexes = new HArray1OfInteger (1, NbVSplit);
+      for (i = 1; i <= NbVSplit; i++) {
+        vsplitIndexes->SetValue (i, VSplit (i));
+      }
+    }
+  }
+}
+
+
+
+Standard_Integer GeomConvert_BSplineSurfaceKnotSplitting::NbUSplits () const {
+   return usplitIndexes->Length();
+}
+
+
+Standard_Integer GeomConvert_BSplineSurfaceKnotSplitting::NbVSplits () const {
+   return vsplitIndexes->Length();
+}
+
+
+Standard_Integer GeomConvert_BSplineSurfaceKnotSplitting::USplitValue (
+
+const Standard_Integer UIndex
+
+) const {
+
+  Standard_RangeError_Raise_if (
+                      UIndex < 1 || UIndex > usplitIndexes->Length(), " ");
+  return usplitIndexes->Value (UIndex);
+}
+
+
+
+Standard_Integer GeomConvert_BSplineSurfaceKnotSplitting::VSplitValue (
+
+const Standard_Integer VIndex
+
+) const {
+
+  Standard_RangeError_Raise_if (
+                      VIndex < 1 || VIndex > vsplitIndexes->Length(), " ");
+  return vsplitIndexes->Value (VIndex);
+}
+
+
+void GeomConvert_BSplineSurfaceKnotSplitting::Splitting (
+
+Array1OfInteger& USplit, 
+Array1OfInteger& VSplit
+
+) const {
+  Standard_Integer i ;
+  for ( i = 1; i <= usplitIndexes->Length(); i++){
+    USplit (i) = usplitIndexes->Value (i);
+  }
+  for (i = 1; i <= vsplitIndexes->Length(); i++){
+    VSplit (i) = vsplitIndexes->Value (i);
+  }
+}