Catmull–Clark subdivision surface: Difference between revisions

Implement the Catmull-Clark surface subdivision ([[wp:Catmull–Clark_subdivision_surface|description on Wikipedia]]), which is an algorithm that maps from a surface (described as a set of points and a set of polygons with vertices at those points) to another more refined surface. The resulting surface will always consist of a mesh of quadrilaterals.

 

 

For edges and vertices not next to a hole, the standard algorithm from above is used.

=={{header|C}}==

[[file:catmull-C.png|center]]

Only the subdivision part. The [[Catmull–Clark_subdivision_surface/C|full source]] is way too long to be shown here. Lots of macros, you'll have to see the full code to know what's what.

{

int i;

return nm;

}</syntaxhighlight>

=={{header|Go}}==

{{trans|Python}}

 

See the original version for full comments.

 

import (

[ 4 23 13 20]

</pre>

=={{header|Haskell}}==

{-# LANGUAGE ScopedTypeVariables #-}

 

(22,[24,15,5,8])

(23,[22,8,5,7])</pre>

=={{header|J}}==

 

 

havePoints=: e."1/~ i.@#

Example use:

 

points=: _1+2*#:i.8

mesh=: 1 A."1 I.(,1-|.)8&$@#&0 1">4 2 1

│ │ 0.555556 0.555556 0.555556│

└──────────┴─────────────────────────────┘</syntaxhighlight>

=={{header|Julia}}==

 

# Point3f0 is a 3-tuple of 32-bit floats for 3-dimensional space, and all Points are 3D.

println("Press Enter to continue", readline())

</syntaxhighlight>

=={{header|Mathematica}}/{{header|Wolfram Language}}==

This implementation supports tris, quads, and higher polys, as well as surfaces with holes.

The function relies on three externally defined general functionality functions:

 

subSetQ[large_,small_List] := And@@(MemberQ[large,#]&/@small)

 

 

 

edges = DeleteDuplicates[Flatten[Partition[#,2,1,-1]&/@faces,1],Sort[#1]==Sort[#2]&];

avgFacePoints=Mean[Points[[#]]] &/@ faces;

 

The implimentation can be tested with polygons with and without holes by using the polydata

 

Function[iteration,

 

For a surface with holes the resulting iterative subdivision will be:

Function[iteration, Graphics3D[

(Polygon[iteration[[1]][[#]]] & /@ iteration[[2]])

 

This code was written in Mathematica 8.

=={{header|Nim}}==

{{trans|Go}}

{{trans|Python}}

import tables

 

[ 2, 20, 13, 17]

[ 4, 23, 13, 20]</pre>

=={{header|OCaml}}==

{{incorrect|OCaml|wrong output data}}

In the [[Catmull–Clark subdivision surface/OCaml|sub-page]] there is also a program in OCaml+OpenGL which displays a cube subdivided 2 times with this algorithm.

 

 

let add3 (x1, y1, z1) (x2, y2, z2) (x3, y3, z3) =

Another implementation which should work with holes, but has only been tested on a cube

{{works with|OCaml|4.02+}}

let zero = { x = 0.0; y = 0.0; z = 0.0 }

let add a b = { x = a.x+.b.x; y = a.y+.b.y; z = a.z+.b.z }

Face: (0.7500, 0.0000, 0.7500) (0.5556, -0.5556, 0.5556) (0.0000, -0.7500, 0.7500) (0.0000, 0.0000, 1.0000)

}</pre>

=={{header|Phix}}==

{{trans|Go}}

<span style="color: #000080;font-style:italic;">-- demo\rosetta\Catmull_Clark_subdivision_surface.exw</span>

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

{ 4,23,13,20}}

</pre>

=={{header|Python}}==

"""

 

graph_output(output_points, output_faces)

</syntaxhighlight>

=={{header|Rust}}==

{{trans|Python}}

pub struct Vector3 {pub x: f64, pub y: f64, pub z: f64, pub w: f64}

 

}

</syntaxhighlight>

=={{header|Tcl}}==

This code handles both holes and arbitrary polygons in the input data.

 

# Use math functions and operators as commands (Lisp-like).

 

<center>[[File:Tcl-Catmull.png]]</center>

=={{header|Wren}}==

{{trans|Go}}

{{libheader|Wren-math}}

{{libheader|Wren-fmt}}

import "/sort" for Sort

import "/math" for Int

[ 4 23 13 20]

</pre>