yapCAD 0.5.0__py2.py3-none-any.whl → 0.5.1__py2.py3-none-any.whl

yapcad/drawable.py

@@ -286,6 +286,23 @@ class Drawable:
             else:
                 raise ValueError("bad value for polystyle: {}".format(self.polystyle))
             
+        elif iscatmullrom(x):
+            from yapcad.spline import sample_catmullrom
+            pts = sample_catmullrom(x)
+            closed = bool(x[2].get('closed', False))
+            for i in range(1, len(pts)):
+                self.draw_line(pts[i-1], pts[i])
+            if closed and pts:
+                self.draw_line(pts[-1], pts[0])
+        elif isnurbs(x):
+            from yapcad.spline import sample_nurbs
+            meta = x[2]
+            default = max(32, len(x[1]) * 8)
+            count = int(meta.get('samples', default))
+            pts = sample_nurbs(x, samples=max(4, count))
+            for i in range(1, len(pts)):
+                self.draw_line(pts[i-1], pts[i])
+            
         elif isinstance(x,Geometry):
             gl = x.geom
             self.draw(gl)
@@ -304,25 +321,362 @@ class Drawable:
         return True
 
 
-    ## Standard color names, ala HTML: https://www.rapidtables.com/web/color/RGB_Color.html
+    ## Standard color names per W3C CSS Color Module Level 4 keywords.
+    # Standardized color keywords (CSS Color Module Level 4) plus
+    # X11 gray/grey ramp entries for broader palette coverage.
     colordict= {
-        'black':   [ [0,0,0], 0],
-        'white':   [ [255,255,255], 7],
-        'red':     [ [255,0,0], 1],
-        'lime':    [ [0,255,0],3],
-        'blue':    [ [0,0,255], 5],
-        'yellow':  [ [255,255,0], 2],
-        'silver':  [ [192,192,192], 9],
-        'gray':    [ [128,128,128], 8],
-        'maroon':  [ [127,0,0], 14],
-        'olive':   [ [127,127,0], 54],
-        'green':   [ [0,127,0], 94],
-        'aqua':    [ [0,255,255], 4],
-        'teal':    [ [0,127,127], 134],
-        'navy':    [ [0,0,128], 174],
-        'fuchsia': [ [255,0,255], 6],
-        'purple':  [ [128,0,128], 214] }
-    
+        'aliceblue': ([240, 248, 255], None),
+        'antiquewhite': ([250, 235, 215], None),
+        'aqua': ([0, 255, 255], 4),
+        'aquamarine': ([127, 255, 212], None),
+        'azure': ([240, 255, 255], None),
+        'beige': ([245, 245, 220], None),
+        'bisque': ([255, 228, 196], None),
+        'black': ([0, 0, 0], 0),
+        'blanchedalmond': ([255, 235, 205], None),
+        'blue': ([0, 0, 255], 5),
+        'blueviolet': ([138, 43, 226], None),
+        'brown': ([165, 42, 42], None),
+        'burlywood': ([222, 184, 135], None),
+        'cadetblue': ([95, 158, 160], None),
+        'chartreuse': ([127, 255, 0], None),
+        'chocolate': ([210, 105, 30], None),
+        'coral': ([255, 127, 80], None),
+        'cornflowerblue': ([100, 149, 237], None),
+        'cornsilk': ([255, 248, 220], None),
+        'crimson': ([220, 20, 60], None),
+        'cyan': ([0, 255, 255], None),
+        'darkblue': ([0, 0, 139], None),
+        'darkcyan': ([0, 139, 139], None),
+        'darkgoldenrod': ([184, 134, 11], None),
+        'darkgray': ([169, 169, 169], None),
+        'darkgreen': ([0, 100, 0], None),
+        'darkgrey': ([169, 169, 169], None),
+        'darkkhaki': ([189, 183, 107], None),
+        'darkmagenta': ([139, 0, 139], None),
+        'darkolivegreen': ([85, 107, 47], None),
+        'darkorange': ([255, 140, 0], None),
+        'darkorchid': ([153, 50, 204], None),
+        'darkred': ([139, 0, 0], None),
+        'darksalmon': ([233, 150, 122], None),
+        'darkseagreen': ([143, 188, 143], None),
+        'darkslateblue': ([72, 61, 139], None),
+        'darkslategray': ([47, 79, 79], None),
+        'darkslategrey': ([47, 79, 79], None),
+        'darkturquoise': ([0, 206, 209], None),
+        'darkviolet': ([148, 0, 211], None),
+        'deeppink': ([255, 20, 147], None),
+        'deepskyblue': ([0, 191, 255], None),
+        'dimgray': ([105, 105, 105], None),
+        'dimgrey': ([105, 105, 105], None),
+        'dodgerblue': ([30, 144, 255], None),
+        'firebrick': ([178, 34, 34], None),
+        'floralwhite': ([255, 250, 240], None),
+        'forestgreen': ([34, 139, 34], None),
+        'fuchsia': ([255, 0, 255], 6),
+        'gainsboro': ([220, 220, 220], None),
+        'ghostwhite': ([248, 248, 255], None),
+        'gold': ([255, 215, 0], None),
+        'goldenrod': ([218, 165, 32], None),
+        'gray': ([128, 128, 128], 8),
+        'gray0': ([0, 0, 0], None),
+        'gray1': ([3, 3, 3], None),
+        'gray10': ([26, 26, 26], None),
+        'gray100': ([255, 255, 255], None),
+        'gray11': ([28, 28, 28], None),
+        'gray12': ([31, 31, 31], None),
+        'gray13': ([33, 33, 33], None),
+        'gray14': ([36, 36, 36], None),
+        'gray15': ([38, 38, 38], None),
+        'gray16': ([41, 41, 41], None),
+        'gray17': ([43, 43, 43], None),
+        'gray18': ([46, 46, 46], None),
+        'gray19': ([48, 48, 48], None),
+        'gray2': ([5, 5, 5], None),
+        'gray20': ([51, 51, 51], None),
+        'gray21': ([54, 54, 54], None),
+        'gray22': ([56, 56, 56], None),
+        'gray23': ([59, 59, 59], None),
+        'gray24': ([61, 61, 61], None),
+        'gray25': ([64, 64, 64], None),
+        'gray26': ([66, 66, 66], None),
+        'gray27': ([69, 69, 69], None),
+        'gray28': ([71, 71, 71], None),
+        'gray29': ([74, 74, 74], None),
+        'gray3': ([8, 8, 8], None),
+        'gray30': ([76, 76, 76], None),
+        'gray31': ([79, 79, 79], None),
+        'gray32': ([82, 82, 82], None),
+        'gray33': ([84, 84, 84], None),
+        'gray34': ([87, 87, 87], None),
+        'gray35': ([89, 89, 89], None),
+        'gray36': ([92, 92, 92], None),
+        'gray37': ([94, 94, 94], None),
+        'gray38': ([97, 97, 97], None),
+        'gray39': ([99, 99, 99], None),
+        'gray4': ([10, 10, 10], None),
+        'gray40': ([102, 102, 102], None),
+        'gray41': ([105, 105, 105], None),
+        'gray42': ([107, 107, 107], None),
+        'gray43': ([110, 110, 110], None),
+        'gray44': ([112, 112, 112], None),
+        'gray45': ([115, 115, 115], None),
+        'gray46': ([117, 117, 117], None),
+        'gray47': ([120, 120, 120], None),
+        'gray48': ([122, 122, 122], None),
+        'gray49': ([125, 125, 125], None),
+        'gray5': ([13, 13, 13], None),
+        'gray50': ([128, 128, 128], None),
+        'gray51': ([130, 130, 130], None),
+        'gray52': ([133, 133, 133], None),
+        'gray53': ([135, 135, 135], None),
+        'gray54': ([138, 138, 138], None),
+        'gray55': ([140, 140, 140], None),
+        'gray56': ([143, 143, 143], None),
+        'gray57': ([145, 145, 145], None),
+        'gray58': ([148, 148, 148], None),
+        'gray59': ([150, 150, 150], None),
+        'gray6': ([15, 15, 15], None),
+        'gray60': ([153, 153, 153], None),
+        'gray61': ([156, 156, 156], None),
+        'gray62': ([158, 158, 158], None),
+        'gray63': ([161, 161, 161], None),
+        'gray64': ([163, 163, 163], None),
+        'gray65': ([166, 166, 166], None),
+        'gray66': ([168, 168, 168], None),
+        'gray67': ([171, 171, 171], None),
+        'gray68': ([173, 173, 173], None),
+        'gray69': ([176, 176, 176], None),
+        'gray7': ([18, 18, 18], None),
+        'gray70': ([178, 178, 178], None),
+        'gray71': ([181, 181, 181], None),
+        'gray72': ([184, 184, 184], None),
+        'gray73': ([186, 186, 186], None),
+        'gray74': ([189, 189, 189], None),
+        'gray75': ([191, 191, 191], None),
+        'gray76': ([194, 194, 194], None),
+        'gray77': ([196, 196, 196], None),
+        'gray78': ([199, 199, 199], None),
+        'gray79': ([201, 201, 201], None),
+        'gray8': ([20, 20, 20], None),
+        'gray80': ([204, 204, 204], None),
+        'gray81': ([207, 207, 207], None),
+        'gray82': ([209, 209, 209], None),
+        'gray83': ([212, 212, 212], None),
+        'gray84': ([214, 214, 214], None),
+        'gray85': ([217, 217, 217], None),
+        'gray86': ([219, 219, 219], None),
+        'gray87': ([222, 222, 222], None),
+        'gray88': ([224, 224, 224], None),
+        'gray89': ([227, 227, 227], None),
+        'gray9': ([23, 23, 23], None),
+        'gray90': ([230, 230, 230], None),
+        'gray91': ([232, 232, 232], None),
+        'gray92': ([235, 235, 235], None),
+        'gray93': ([237, 237, 237], None),
+        'gray94': ([240, 240, 240], None),
+        'gray95': ([242, 242, 242], None),
+        'gray96': ([245, 245, 245], None),
+        'gray97': ([247, 247, 247], None),
+        'gray98': ([250, 250, 250], None),
+        'gray99': ([252, 252, 252], None),
+        'green': ([0, 127, 0], 94),
+        'greenyellow': ([173, 255, 47], None),
+        'grey': ([128, 128, 128], None),
+        'grey0': ([0, 0, 0], None),
+        'grey1': ([3, 3, 3], None),
+        'grey10': ([26, 26, 26], None),
+        'grey100': ([255, 255, 255], None),
+        'grey11': ([28, 28, 28], None),
+        'grey12': ([31, 31, 31], None),
+        'grey13': ([33, 33, 33], None),
+        'grey14': ([36, 36, 36], None),
+        'grey15': ([38, 38, 38], None),
+        'grey16': ([41, 41, 41], None),
+        'grey17': ([43, 43, 43], None),
+        'grey18': ([46, 46, 46], None),
+        'grey19': ([48, 48, 48], None),
+        'grey2': ([5, 5, 5], None),
+        'grey20': ([51, 51, 51], None),
+        'grey21': ([54, 54, 54], None),
+        'grey22': ([56, 56, 56], None),
+        'grey23': ([59, 59, 59], None),
+        'grey24': ([61, 61, 61], None),
+        'grey25': ([64, 64, 64], None),
+        'grey26': ([66, 66, 66], None),
+        'grey27': ([69, 69, 69], None),
+        'grey28': ([71, 71, 71], None),
+        'grey29': ([74, 74, 74], None),
+        'grey3': ([8, 8, 8], None),
+        'grey30': ([76, 76, 76], None),
+        'grey31': ([79, 79, 79], None),
+        'grey32': ([82, 82, 82], None),
+        'grey33': ([84, 84, 84], None),
+        'grey34': ([87, 87, 87], None),
+        'grey35': ([89, 89, 89], None),
+        'grey36': ([92, 92, 92], None),
+        'grey37': ([94, 94, 94], None),
+        'grey38': ([97, 97, 97], None),
+        'grey39': ([99, 99, 99], None),
+        'grey4': ([10, 10, 10], None),
+        'grey40': ([102, 102, 102], None),
+        'grey41': ([105, 105, 105], None),
+        'grey42': ([107, 107, 107], None),
+        'grey43': ([110, 110, 110], None),
+        'grey44': ([112, 112, 112], None),
+        'grey45': ([115, 115, 115], None),
+        'grey46': ([117, 117, 117], None),
+        'grey47': ([120, 120, 120], None),
+        'grey48': ([122, 122, 122], None),
+        'grey49': ([125, 125, 125], None),
+        'grey5': ([13, 13, 13], None),
+        'grey50': ([128, 128, 128], None),
+        'grey51': ([130, 130, 130], None),
+        'grey52': ([133, 133, 133], None),
+        'grey53': ([135, 135, 135], None),
+        'grey54': ([138, 138, 138], None),
+        'grey55': ([140, 140, 140], None),
+        'grey56': ([143, 143, 143], None),
+        'grey57': ([145, 145, 145], None),
+        'grey58': ([148, 148, 148], None),
+        'grey59': ([150, 150, 150], None),
+        'grey6': ([15, 15, 15], None),
+        'grey60': ([153, 153, 153], None),
+        'grey61': ([156, 156, 156], None),
+        'grey62': ([158, 158, 158], None),
+        'grey63': ([161, 161, 161], None),
+        'grey64': ([163, 163, 163], None),
+        'grey65': ([166, 166, 166], None),
+        'grey66': ([168, 168, 168], None),
+        'grey67': ([171, 171, 171], None),
+        'grey68': ([173, 173, 173], None),
+        'grey69': ([176, 176, 176], None),
+        'grey7': ([18, 18, 18], None),
+        'grey70': ([178, 178, 178], None),
+        'grey71': ([181, 181, 181], None),
+        'grey72': ([184, 184, 184], None),
+        'grey73': ([186, 186, 186], None),
+        'grey74': ([189, 189, 189], None),
+        'grey75': ([191, 191, 191], None),
+        'grey76': ([194, 194, 194], None),
+        'grey77': ([196, 196, 196], None),
+        'grey78': ([199, 199, 199], None),
+        'grey79': ([201, 201, 201], None),
+        'grey8': ([20, 20, 20], None),
+        'grey80': ([204, 204, 204], None),
+        'grey81': ([207, 207, 207], None),
+        'grey82': ([209, 209, 209], None),
+        'grey83': ([212, 212, 212], None),
+        'grey84': ([214, 214, 214], None),
+        'grey85': ([217, 217, 217], None),
+        'grey86': ([219, 219, 219], None),
+        'grey87': ([222, 222, 222], None),
+        'grey88': ([224, 224, 224], None),
+        'grey89': ([227, 227, 227], None),
+        'grey9': ([23, 23, 23], None),
+        'grey90': ([230, 230, 230], None),
+        'grey91': ([232, 232, 232], None),
+        'grey92': ([235, 235, 235], None),
+        'grey93': ([237, 237, 237], None),
+        'grey94': ([240, 240, 240], None),
+        'grey95': ([242, 242, 242], None),
+        'grey96': ([245, 245, 245], None),
+        'grey97': ([247, 247, 247], None),
+        'grey98': ([250, 250, 250], None),
+        'grey99': ([252, 252, 252], None),
+        'honeydew': ([240, 255, 240], None),
+        'hotpink': ([255, 105, 180], None),
+        'indianred': ([205, 92, 92], None),
+        'indigo': ([75, 0, 130], None),
+        'ivory': ([255, 255, 240], None),
+        'khaki': ([240, 230, 140], None),
+        'lavender': ([230, 230, 250], None),
+        'lavenderblush': ([255, 240, 245], None),
+        'lawngreen': ([124, 252, 0], None),
+        'lemonchiffon': ([255, 250, 205], None),
+        'lightblue': ([173, 216, 230], None),
+        'lightcoral': ([240, 128, 128], None),
+        'lightcyan': ([224, 255, 255], None),
+        'lightgoldenrodyellow': ([250, 250, 210], None),
+        'lightgray': ([211, 211, 211], None),
+        'lightgreen': ([144, 238, 144], None),
+        'lightgrey': ([211, 211, 211], None),
+        'lightpink': ([255, 182, 193], None),
+        'lightsalmon': ([255, 160, 122], None),
+        'lightseagreen': ([32, 178, 170], None),
+        'lightskyblue': ([135, 206, 250], None),
+        'lightslategray': ([119, 136, 153], None),
+        'lightslategrey': ([119, 136, 153], None),
+        'lightsteelblue': ([176, 196, 222], None),
+        'lightyellow': ([255, 255, 224], None),
+        'lime': ([0, 255, 0], 3),
+        'limegreen': ([50, 205, 50], None),
+        'linen': ([250, 240, 230], None),
+        'magenta': ([255, 0, 255], None),
+        'maroon': ([127, 0, 0], 14),
+        'mediumaquamarine': ([102, 205, 170], None),
+        'mediumblue': ([0, 0, 205], None),
+        'mediumorchid': ([186, 85, 211], None),
+        'mediumpurple': ([147, 112, 219], None),
+        'mediumseagreen': ([60, 179, 113], None),
+        'mediumslateblue': ([123, 104, 238], None),
+        'mediumspringgreen': ([0, 250, 154], None),
+        'mediumturquoise': ([72, 209, 204], None),
+        'mediumvioletred': ([199, 21, 133], None),
+        'midnightblue': ([25, 25, 112], None),
+        'mintcream': ([245, 255, 250], None),
+        'mistyrose': ([255, 228, 225], None),
+        'moccasin': ([255, 228, 181], None),
+        'navajowhite': ([255, 222, 173], None),
+        'navy': ([0, 0, 128], 174),
+        'oldlace': ([253, 245, 230], None),
+        'olive': ([127, 127, 0], 54),
+        'olivedrab': ([107, 142, 35], None),
+        'orange': ([255, 165, 0], None),
+        'orangered': ([255, 69, 0], None),
+        'orchid': ([218, 112, 214], None),
+        'palegoldenrod': ([238, 232, 170], None),
+        'palegreen': ([152, 251, 152], None),
+        'paleturquoise': ([175, 238, 238], None),
+        'palevioletred': ([219, 112, 147], None),
+        'papayawhip': ([255, 239, 213], None),
+        'peachpuff': ([255, 218, 185], None),
+        'peru': ([205, 133, 63], None),
+        'pink': ([255, 192, 203], None),
+        'plum': ([221, 160, 221], None),
+        'powderblue': ([176, 224, 230], None),
+        'purple': ([128, 0, 128], 214),
+        'rebeccapurple': ([102, 51, 153], None),
+        'red': ([255, 0, 0], 1),
+        'rosybrown': ([188, 143, 143], None),
+        'royalblue': ([65, 105, 225], None),
+        'saddlebrown': ([139, 69, 19], None),
+        'salmon': ([250, 128, 114], None),
+        'sandybrown': ([244, 164, 96], None),
+        'seagreen': ([46, 139, 87], None),
+        'seashell': ([255, 245, 238], None),
+        'sienna': ([160, 82, 45], None),
+        'silver': ([192, 192, 192], 9),
+        'skyblue': ([135, 206, 235], None),
+        'slateblue': ([106, 90, 205], None),
+        'slategray': ([112, 128, 144], None),
+        'slategrey': ([112, 128, 144], None),
+        'snow': ([255, 250, 250], None),
+        'springgreen': ([0, 255, 127], None),
+        'steelblue': ([70, 130, 180], None),
+        'tan': ([210, 180, 140], None),
+        'teal': ([0, 127, 127], 134),
+        'thistle': ([216, 191, 216], None),
+        'tomato': ([255, 99, 71], None),
+        'turquoise': ([64, 224, 208], None),
+        'violet': ([238, 130, 238], None),
+        'wheat': ([245, 222, 179], None),
+        'white': ([255, 255, 255], 7),
+        'whitesmoke': ([245, 245, 245], None),
+        'yellow': ([255, 255, 0], 2),
+        'yellowgreen': ([154, 205, 50], None),
+    }
+
     ## AUTOCAD color index:
     ## https://forums.autodesk.com/t5/visual-lisp-autolisp-and-general/
     ## rgb-values-of-the-256-standard-indexed-colors/td-p/848912
@@ -614,14 +968,33 @@ class Drawable:
     ## function to convert between different color representations 
     def thing2color(self,thing,convert='b',colormap=None,colordict=None):
         def _b2f(c):
-            return [ c[0]/255.0,c[1]/255.0,c[2]/255.0 ]
+            return [c[0] / 255.0, c[1] / 255.0, c[2] / 255.0]
+
         def _f2b(c):
-            return [ round(c[0]*255.0),rount(c[1]*255.0),round(c[2]*255.0) ]
+            return [round(c[0] * 255.0), round(c[1] * 255.0), round(c[2] * 255.0)]
+
+        def _nearest_index(rgb):
+            best_idx = 0
+            best_dist = float('inf')
+            for idx, candidate in enumerate(colormap):
+                if not isinstance(candidate, (list, tuple)) or len(candidate) != 3:
+                    continue
+                dist = ((candidate[0] - rgb[0]) ** 2 +
+                        (candidate[1] - rgb[1]) ** 2 +
+                        (candidate[2] - rgb[2]) ** 2)
+                if dist < best_dist:
+                    best_idx = idx
+                    best_dist = dist
+                    if dist == 0:
+                        break
+            return best_idx
+
         def _b2i(c):
             for i in range(len(colormap)):
-                if colormap[i] == thing:
+                if colormap[i] == c:
                     return i
-            return False
+            return _nearest_index(c)
+
         def _f2i(c):
             return _b2i(_f2b(c))
         def _isgoodf(x):
@@ -657,13 +1030,19 @@ class Drawable:
             else:
                 return thing
         elif isinstance(thing,str):
-            cd = colordict[thing]
+            key = thing.lower()
+            if key not in colordict:
+                raise ValueError('bad color name passed to thing2color: {}'.format(thing))
+            cd = colordict[key]
             if isinstance(cd,bool) and cd == False:
                 raise ValueError('bad color name passed to thing2color: {}'.format(thing))
             if convert == 'i':
-                return cd[1]
+                idx = cd[1]
+                if idx is None:
+                    idx = _nearest_index(cd[0])
+                return idx
             else:
-                c = cd[0]
+                c = list(cd[0])
         elif isinstance(thing,int):
             if thing < 0 or thing > len(colormap):
                 raise ValueError('colormap index out of range: {}'.format(thing))
@@ -681,4 +1060,3 @@ class Drawable:
             return _b2f(c)
         return list(c)
     
-

yapcad/geom.py

@@ -409,6 +409,92 @@ and polygon-specific computational geometry operations, notably:
 
 """
 
+## spline curves
+## =============
+##
+## Modern procedural CAD workflows frequently mix straight segments with
+## smooth interpolants.  **yapCAD** represents spline curves as tagged lists so
+## they can travel through geometry lists and be sampled on demand.
+
+
+def catmullrom(points, closed=False, alpha=0.5):
+    """Return a Catmull-Rom spline definition."""
+
+    pts = [point(p) for p in points]
+    if len(pts) < 2:
+        raise ValueError('catmullrom requires at least two control points')
+    return ['catmullrom', pts, {'closed': bool(closed), 'alpha': float(alpha)}]
+
+
+def iscatmullrom(obj):
+    """Return ``True`` if *obj* is a Catmull-Rom spline."""
+
+    return (
+        isinstance(obj, list)
+        and len(obj) == 3
+        and obj[0] == 'catmullrom'
+        and isinstance(obj[1], list)
+        and isinstance(obj[2], dict)
+    )
+
+
+def nurbs(control_points, *, degree=3, weights=None, knots=None):
+    """Return a NURBS curve definition."""
+
+    pts = [point(p) for p in control_points]
+    n = len(pts)
+    if n == 0:
+        raise ValueError('nurbs requires at least one control point')
+    if degree < 1:
+        raise ValueError('nurbs degree must be >= 1')
+    if n < degree + 1:
+        raise ValueError('nurbs requires len(control_points) >= degree + 1')
+
+    if weights is None:
+        wts = [1.0] * n
+    else:
+        if len(weights) != n:
+            raise ValueError('weights must match number of control points')
+        wts = [float(w) for w in weights]
+
+    if knots is None:
+        knots = _open_uniform_knot_vector(n, degree)
+    else:
+        if len(knots) != n + degree + 1:
+            raise ValueError('knot vector must have length n + degree + 1')
+        knots = [float(k) for k in knots]
+
+    return ['nurbs', pts, {'degree': int(degree), 'weights': wts, 'knots': knots}]
+
+
+def isnurbs(obj):
+    """Return ``True`` if *obj* is a NURBS curve."""
+
+    return (
+        isinstance(obj, list)
+        and len(obj) == 3
+        and obj[0] == 'nurbs'
+        and isinstance(obj[1], list)
+        and isinstance(obj[2], dict)
+    )
+
+
+def _open_uniform_knot_vector(count, degree):
+    """Generate an open-uniform knot vector of length ``count + degree + 1``."""
+
+    length = count + degree + 1
+    knots = [0.0] * (degree + 1)
+
+    interior_knots = count - degree - 1
+    if interior_knots > 0:
+        denom = count - degree
+        for j in range(1, interior_knots + 1):
+            knots.append(j / denom)
+
+    knots.extend([1.0] * (degree + 1))
+    return knots[:length]
+
+
 from math import *
 import mpmath as mpm
 import copy
@@ -2495,6 +2581,8 @@ def intersectGeomListXY(g,gl,inside=True,params=False):
         if gtype == 'glist':
             r = intersectGeomListXY(gl[0],g,inside,params)
             if params:
+                if isinstance(r,bool):
+                    return r
                 return [ r[1], r[0] ]
             else:
                 return r
@@ -2719,6 +2807,12 @@ def sample(x,u):
         return samplearc(x,u)
     elif ispoly(x):
         return samplepoly(x,u)
+    elif iscatmullrom(x):
+        from yapcad.spline import evaluate_catmullrom
+        return evaluate_catmullrom(x, u)
+    elif isnurbs(x):
+        from yapcad.spline import evaluate_nurbs
+        return evaluate_nurbs(x, u)
     elif isgeomlist(x):
         return samplegeomlist(x,u)
     else:
@@ -2742,11 +2836,33 @@ def unsample(x,p):
         return unsamplearc(x,p)
     elif ispoly(x):
         return unsamplepoly(x,p)
+    elif iscatmullrom(x):
+        from yapcad.spline import evaluate_catmullrom
+        return _unsample_curve(x, p, evaluate_catmullrom)
+    elif isnurbs(x):
+        from yapcad.spline import evaluate_nurbs
+        return _unsample_curve(x, p, evaluate_nurbs)
     elif isgeomlist(x):
         return unsamplegeomlist(x,p)
     else:
         raise ValueError("inappropriate type for unasample(): "+str(x))
 
+
+def _unsample_curve(curve, target, evaluator, *, steps=200):
+    """Return approximate parameter for ``target`` on ``curve`` or ``False``."""
+
+    target = point(target)
+    best_u = 0.0
+    best_d = float('inf')
+    for i in range(steps + 1):
+        u = i / steps
+        sample_pt = evaluator(curve, u)
+        d = dist(sample_pt, target)
+        if d < best_d:
+            best_d = d
+            best_u = u
+    return best_u if best_d <= epsilon * 10 else False
+
 def segment(x,u1,u2):
     """ given a figure x, create a new figure spanning the specified interval in the original figure
     """