Python: module fabmetheus_utilities.euclidean

fabmetheus_utilities.euclidean ($Date: 2008/21/04 $) | index /home/enrique/Desktop/backup/babbleold/script/reprap/fabmetheus/fabmetheus_utilities/euclidean.py

`Euclidean is a collection of python utilities for complex numbers, paths, polygons & Vector3s.
To use euclidean, install python 2.x on your machine, which is avaliable from http://www.python.org/download/
Then in the folder which euclidean is in, type 'python' in a shell to run the python interpreter. Finally type 'import euclidean' to import these utilities and 'from vector3 import Vector3' to import the Vector3 class.
Below are examples of euclidean use.
>>> from euclidean import *
>>> origin=complex()
>>> right=complex(1.0,0.0)
>>> back=complex(0.0,1.0)
>>> getMaximum(right,back)
1.0, 1.0
>>> polygon=[origin, right, back]
>>> getLoopLength(polygon)
3.4142135623730949
>>> getAreaLoop(polygon)
0.5`

Modules

``

__init__ cStringIO | math random | fabmetheus_utilities.xml_simple_writer |

Classes

``

DistanceIndex
Endpoint
LoopLayer
NestedRing
  NestedBand
PathZ
ProjectiveSpace
XIntersectionIndex

class DistanceIndex
`` | `A class to hold the distance and the index of the loop. `

Methods defined here:

__init__(self, distance, index)
  `Initialize.`

__repr__(self)
  `Get the string representation of this distance index.`

class Endpoint
`` | `The endpoint of a segment. `

Methods defined here:

__repr__(self)
  `Get the string representation of this Endpoint.`

getClosestEndpoint(self, endpoints)
  `Get closest endpoint.`

getClosestMiss(self, endpoints, path, pixelDictionary, sharpestProduct, width)
  `Get the closest endpoint which the segment to that endpoint misses the other extrusions.`

getClosestMissCheckEndpointPath(self, endpoints, path, pixelDictionary, sharpestProduct, width)
  `Get the closest endpoint which the segment to that endpoint misses the other extrusions, also checking the path of the endpoint.`

getFromOtherPoint(self, otherEndpoint, point)
  `Initialize from other endpoint.`

class LoopLayer
`` | `Loops with a z. `

Methods defined here:

__init__(self, z)
  `Initialize.`

__repr__(self)
  `Get the string representation of this loop layer.`

class NestedBand(NestedRing)
`` | `A loop that surrounds paths. `

Methods defined here:

__init__(self)
  `Initialize.`

__repr__(self)
  `Get the string representation of this nested ring.`

addPerimeterInner(self, extrusionHalfWidth, oldOrderedLocation, skein, threadSequence)
  `Add to the edge and the inner island.`

addToBoundary(self, vector3)
  `Add vector3 to boundary.`

addToLoop(self, vector3)
  `Add vector3 to loop.`

addToThreads(self, extrusionHalfWidth, oldOrderedLocation, skein, threadSequence)
  `Add to paths from the last location.`

getFillLoops(self, penultimateFillLoops)
  `Get last fill loops from the outside loop and the loops inside the inside loops.`

getLoopsToBeFilled(self)
  `Get last fill loops from the outside loop and the loops inside the inside loops.`

getSurroundingBoundaries(self)
  `Get the boundary of the surronding loop plus any boundaries of the innerNestedRings.`

transferClosestFillLoops(self, extrusionHalfWidth, oldOrderedLocation, skein, threadSequence)
  `Transfer closest fill loops.`

transferInfillPaths(self, extrusionHalfWidth, oldOrderedLocation, skein, threadSequence)
  `Transfer the infill paths.`

transferPaths(self, paths)
  `Transfer paths.`

Methods inherited from NestedRing:

addFlattenedNestedRings(self, flattenedNestedRings)
  `Add flattened nested rings.`

getFromInsideSurroundings(self, inputSurroundingInsides)
  `Initialize from inside nested rings.`

class NestedRing
`` | `A nested ring. `

Methods defined here:

__init__(self)
  `Initialize.`

__repr__(self)
  `Get the string representation of this nested ring.`

addFlattenedNestedRings(self, flattenedNestedRings)
  `Add flattened nested rings.`

getFromInsideSurroundings(self, inputSurroundingInsides)
  `Initialize from inside nested rings.`

class PathZ
`` | `Complex path with a z. `

Methods defined here:

__init__(self, z)

__repr__(self)
  `Get the string representation of this path z.`

class ProjectiveSpace
`` | `Class to define a projective space. `

Methods defined here:

__init__(self, basisX=(1.0, 0.0, 0.0), basisY=(0.0, 1.0, 0.0), basisZ=(0.0, 0.0, 1.0))
  `Initialize the basis vectors.`

__repr__(self)
  `Get the string representation of this ProjectivePlane.`

getByBasisXZ(self, basisX, basisZ)
  `Get by x basis x and y basis.`

getByBasisZFirst(self, basisZ, firstVector3)
  `Get by basisZ and first.`

getByBasisZTop(self, basisZ, top)
  `Get by basisZ and top.`

getByLatitudeLongitude(self, viewpointLatitude, viewpointLongitude)
  `Get by latitude and longitude.`

getByTilt(self, tilt)
  `Get by latitude and longitude.`

getComplexByComplex(self, pointComplex)
  `Get complex by complex point.`

getCopy(self)
  `Get copy.`

getDotComplex(self, point)
  `Get the dot complex.`

getDotVector3(self, point)
  `Get the dot vector3.`

getNextSpace(self, nextNormal)
  `Get next space by next normal.`

getSpaceByXYScaleAngle(self, angle, scale)
  `Get space by angle and scale.`

getVector3ByPoint(self, point)
  `Get vector3 by point.`

normalize(self)
  `Normalize.`

unbuckle(self, maximumUnbuckling, normal)
  `Unbuckle space.`

class XIntersectionIndex
`` | `A class to hold the x intersection position and the index of the loop which intersected. `

Methods defined here:

__cmp__(self, other)
  `Get comparison in order to sort x intersections in ascending order of x.`

__eq__(self, other)
  `Determine whether this XIntersectionIndex is identical to other one.`

__init__(self, index, x)
  `Initialize.`

__ne__(self, other)
  `Determine whether this XIntersectionIndex is not identical to other one.`

__repr__(self)
  `Get the string representation of this x intersection.`

Functions

``

addElementToListDictionary(element, key, listDictionary)
  `Add an element to the list table.`

addElementToListDictionaryIfNotThere(element, key, listDictionary)
  `Add the value to the lists.`

addElementToPixelList(element, pixelDictionary, x, y)
  `Add an element to the pixel list.`

addElementToPixelListFromPoint(element, pixelDictionary, point)
  `Add an element to the pixel list.`

addHorizontallyBoundedPoint(begin, center, end, horizontalBegin, horizontalEnd, path)
  `Add point if it is within the horizontal bounds.`

addListToListTable(elementList, key, listDictionary)
  `Add a list to the list table.`

addLoopToPixelTable(loop, pixelDictionary, width)
  `Add loop to the pixel table.`

addNestedRingBeginning(distanceFeedRate, loop, z)
  `Add nested ring beginning to gcode output.`

addPathToPixelTable(path, pixelDictionary, value, width)
  `Add path to the pixel table.`

addPixelTableToPixelTable(fromPixelTable, intoPixelTable)
  `Add from pixel table to the into pixel table.`

addPixelToPixelTableWithSteepness(isSteep, pixelDictionary, value, x, y)
  `Add pixels to the pixel table with steepness.`

addPointToPath(path, pixelDictionary, point, value, width)
  `Add a point to a path and the pixel table.`

addSegmentToPixelTable(beginComplex, endComplex, pixelDictionary, shortenDistanceBegin, shortenDistanceEnd, width)
  `Add line segment to the pixel table.`

addSquareTwoToPixelDictionary(pixelDictionary, point, value, width)
  `Add square with two pixels around the center to pixel dictionary.`

addToThreadsFromLoop(extrusionHalfWidth, gcodeType, loop, oldOrderedLocation, skein)
  `Add to threads from the last location from loop.`

addToThreadsRemove(extrusionHalfWidth, nestedRings, oldOrderedLocation, skein, threadSequence)
  `Add to threads from the last location from nested rings.`

addValueSegmentToPixelTable(beginComplex, endComplex, pixelDictionary, value, width)
  `Add line segment to the pixel table.`

addValueToOutput(depth, keyInput, output, value)
  `Add value to the output.`

addXIntersectionIndexesFromLoopListsY(loopLists, xIntersectionIndexList, y)
  `Add the x intersection indexes for the loop lists.`

addXIntersectionIndexesFromLoopY(loop, solidIndex, xIntersectionIndexList, y)
  `Add the x intersection indexes for a loop.`

addXIntersectionIndexesFromLoopsY(loops, solidIndex, xIntersectionIndexList, y)
  `Add the x intersection indexes for the loops.`

addXIntersectionIndexesFromSegment(index, segment, xIntersectionIndexList)
  `Add the x intersection indexes from the segment.`

addXIntersectionIndexesFromSegments(index, segments, xIntersectionIndexList)
  `Add the x intersection indexes from the segments.`

addXIntersectionIndexesFromXIntersections(index, xIntersectionIndexList, xIntersections)
  `Add the x intersection indexes from the XIntersections.`

addXIntersections(loop, xIntersections, y)
  `Add the x intersections for a loop.`

addXIntersectionsFromLoopForTable(loop, xIntersectionsTable, width)
  `Add the x intersections for a loop into a table.`

addXIntersectionsFromLoops(loops, xIntersections, y)
  `Add the x intersections for the loops.`

addXIntersectionsFromLoopsForTable(loops, xIntersectionsTable, width)
  `Add the x intersections for a loop into a table.`

compareSegmentLength(endpoint, otherEndpoint)
  `Get comparison in order to sort endpoints in ascending order of segment length.`

concatenateRemovePath(connectedPaths, pathIndex, paths, pixelDictionary, segments, sharpestProduct, width)
  `Get connected paths from paths.`

getAngleAroundZAxisDifference(subtractFromVec3, subtractVec3)
  `Get the angle around the Z axis difference between a pair of Vector3s.`

getAngleDifferenceByComplex(subtractFromComplex, subtractComplex)
  `Get the angle between a pair of normalized complexes.`

getAreaLoop(loop)
  `Get the area of a complex polygon.`

getAreaLoopAbsolute(loop)
  `Get the absolute area of a complex polygon.`

getAreaLoops(loops)
  `Get the area of a list of complex polygons.`

getAreaVector3LoopAbsolute(loop)
  `Get the absolute area of a vector3 polygon.`

getAroundLoop(begin, end, loop)
  `Get an arc around a loop.`

getAwayPath(path, radius)
  `Get a path with only the points that are far enough away from each other, except for the last point.`

getAwayPoints(points, radius)
  `Get a path with only the points that are far enough away from each other.`

getBooleanFromDictionary(defaultBoolean, dictionary, key)
  `Get boolean from the dictionary and key.`

getBooleanFromValue(value)
  `Get boolean from the word.`

getBottomByPath(path)
  `Get the bottom of the path.`

getBottomByPaths(paths)
  `Get the bottom of the paths.`

getClippedAtEndLoopPath(clip, loopPath)
  `Get a clipped loop path.`

getClippedLoopPath(clip, loopPath)
  `Get a clipped loop path.`

getClippedSimplifiedLoopPath(clip, loopPath, radius)
  `Get a clipped and simplified loop path.`

getClosestDistanceIndexToLine(point, loop)
  `Get the distance squared to the closest segment of the loop and index of that segment.`

getClosestPointOnSegment(segmentBegin, segmentEnd, point)
  `Get the closest point on the segment.`

getComplexByCommaString(valueCommaString)
  `Get the commaString as a complex.`

getComplexByWords(words, wordIndex=0)
  `Get the complex by the first two words.`

getComplexDefaultByDictionary(defaultComplex, dictionary, key)
  `Get the value as a complex.`

getComplexDefaultByDictionaryKeys(defaultComplex, dictionary, keyX, keyY)
  `Get the value as a complex.`

getComplexPath(vector3Path)
  `Get the complex path from the vector3 path.`

getComplexPathByMultiplier(multiplier, path)
  `Get the multiplied complex path.`

getComplexPaths(vector3Paths)
  `Get the complex paths from the vector3 paths.`

getComplexPolygon(center, radius, sides, startAngle=0.0)
  `Get the complex polygon.`

getComplexPolygonByComplexRadius(radius, sides, startAngle=0.0)
  `Get the complex polygon.`

getComplexPolygonByStartEnd(endAngle, radius, sides, startAngle=0.0)
  `Get the complex polygon by start and end angle.`

getConcatenatedList(originalLists)
  `Get the lists as one concatenated list.`

getConnectedPaths(paths, pixelDictionary, sharpestProduct, width)
  `Get connected paths from paths.`

getCrossProduct(firstComplex, secondComplex)
  `Get z component cross product of a pair of complexes.`

getDecimalPlacesCarried(extraDecimalPlaces, value)
  `Get decimal places carried by the decimal places of the value plus the extraDecimalPlaces.`

getDiagonalFlippedLoop(loop)
  `Get loop flipped over the dialogonal, in other words with the x and y swapped.`

getDiagonalFlippedLoops(loops)
  `Get loops flipped over the dialogonal, in other words with the x and y swapped.`

getDictionaryString(dictionary)
  `Get the dictionary string.`

getDistanceToLine(begin, end, point)
  `Get the distance from a vector3 point to an infinite line.`

getDistanceToLineByPath(begin, end, path)
  `Get the maximum distance from a path to an infinite line.`

getDistanceToLineByPaths(begin, end, paths)
  `Get the maximum distance from paths to an infinite line.`

getDistanceToPlaneSegment(segmentBegin, segmentEnd, point)
  `Get the distance squared from a point to the x & y components of a segment.`

getDotProduct(firstComplex, secondComplex)
  `Get the dot product of a pair of complexes.`

getDotProductPlusOne(firstComplex, secondComplex)
  `Get the dot product plus one of the x and y components of a pair of Vector3s.`

getDurationString(seconds)
  `Get the duration string.`

getEndpointFromPath(path, pathIndex)
  `Get endpoint segment from a path.`

getEndpointsFromSegmentTable(segmentTable)
  `Get the endpoints from the segment table.`

getEndpointsFromSegments(segments)
  `Get endpoints from segments.`

getEnumeratorKeys(enumerator, keys)
  `Get enumerator keys.`

getEnumeratorKeysAlwaysList(enumerator, keys)
  `Get enumerator keys.`

getEnumeratorKeysExceptForOneArgument(enumerator, keys)
  `Get enumerator keys, except when there is one argument.`

getFillOfSurroundings(nestedRings, penultimateFillLoops)
  `Get extra fill loops of nested rings.`

getFlattenedNestedRings(nestedRings)
  `Get flattened nested rings.`

getFloatDefaultByDictionary(defaultFloat, dictionary, key)
  `Get the value as a float.`

getFloatFromValue(value)
  `Get the value as a float.`

getFourSignificantFigures(number)
  `Get number rounded to four significant figures as a string.`

getHalfSimplifiedLoop(loop, radius, remainder)
  `Get the loop with half of the points inside the channel removed.`

getHalfSimplifiedPath(path, radius, remainder)
  `Get the path with half of the points inside the channel removed.`

getHorizontallyBoundedPath(horizontalBegin, horizontalEnd, path)
  `Get horizontally bounded path.`

getIncrementFromRank(rank)
  `Get the increment from the rank which is 0 at 1 and increases by three every power of ten.`

getInsidesAddToOutsides(loops, outsides)
  `Add loops to either the insides or outsides.`

getIntFromValue(value)
  `Get the value as an int.`

getIntermediateLocation(alongWay, begin, end)
  `Get the intermediate location between begin and end.`

getIntersectionOfXIntersectionIndexes(totalSolidSurfaceThickness, xIntersectionIndexList)
  `Get x intersections from surrounding layers.`

getIntersectionOfXIntersectionsTables(xIntersectionsTables)
  `Get the intersection of the XIntersections tables.`

getIsInFilledRegion(loops, point)
  `Determine if the point is in the filled region of the loops.`

getIsInFilledRegionByPaths(loops, paths)
  `Determine if the point of any path is in the filled region of the loops.`

getIsRadianClose(firstRadian, secondRadian)
  `Determine if the firstRadian is close to the secondRadian.`

getIsWiddershinsByVector3(polygon)
  `Determine if the polygon goes round in the widdershins direction.`

getJoinOfXIntersectionIndexes(xIntersectionIndexList)
  `Get joined x intersections from surrounding layers.`

getLargestLoop(loops)
  `Get largest loop from loops.`

getLeftPoint(points)
  `Get the leftmost complex point in the points.`

getLeftPointIndex(points)
  `Get the index of the leftmost complex point in the points.`

getListTableElements(listDictionary)
  `Get all the element in a list table.`

getLoopCentroid(polygonComplex)
  `Get the area of a complex polygon using http://en.wikipedia.org/wiki/Centroid.`

getLoopConvex(points)
  `Get convex hull of points using gift wrap algorithm.`

getLoopConvexCentroid(polygonComplex)
  `Get centroid of the convex hull of a complex polygon.`

getLoopInsideContainingLoop(containingLoop, loops)
  `Get a loop that is inside the containing loop.`

getLoopLength(polygon)
  `Get the length of a polygon perimeter.`

getLoopStartingClosest(extrusionHalfWidth, location, loop)
  `Add to threads from the last location from loop.`

getLoopWithoutCloseEnds(close, loop)
  `Get loop without close ends.`

getLoopWithoutCloseSequentialPoints(close, loop)
  `Get loop without close sequential points.`

getMaximum(firstComplex, secondComplex)
  `Get a complex with each component the maximum of the respective components of a pair of complexes.`

getMaximumByComplexPath(path)
  `Get a complex with each component the maximum of the respective components of a complex path.`

getMaximumByComplexPaths(paths)
  `Get a complex with each component the maximum of the respective components of complex paths.`

getMaximumByVector3Path(path)
  `Get a vector3 with each component the maximum of the respective components of a vector3 path.`

getMaximumByVector3Paths(paths)
  `Get a complex with each component the maximum of the respective components of a complex path.`

getMaximumSpan(loop)
  `Get the maximum span of the loop.`

getMinimum(firstComplex, secondComplex)
  `Get a complex with each component the minimum of the respective components of a pair of complexes.`

getMinimumByComplexPath(path)
  `Get a complex with each component the minimum of the respective components of a complex path.`

getMinimumByComplexPaths(paths)
  `Get a complex with each component the minimum of the respective components of complex paths.`

getMinimumByVector3Path(path)
  `Get a vector3 with each component the minimum of the respective components of a vector3 path.`

getMinimumByVector3Paths(paths)
  `Get a complex with each component the minimum of the respective components of a complex path.`

getMirrorPath(path)
  `Get mirror path.`

getNormal(begin, center, end)
  `Get normal.`

getNormalByPath(path)
  `Get normal by path.`

getNormalWeighted(begin, center, end)
  `Get weighted normal.`

getNormalized(complexNumber)
  `Get the normalized complex.`

getNumberOfIntersectionsToLeft(loop, point)
  `Get the number of intersections through the loop for the line going left.`

getNumberOfIntersectionsToLeftOfLoops(loops, point)
  `Get the number of intersections through the loop for the line starting from the left point and going left.`

getOrderedNestedRings(nestedRings)
  `Get ordered nestedRings from nestedRings.`

getPathCopy(path)
  `Get path copy.`

getPathLength(path)
  `Get the length of a path ( an open polyline ).`

getPathsFromEndpoints(endpoints, maximumConnectionLength, pixelDictionary, sharpestProduct, width)
  `Get paths from endpoints.`

getPlaneDot(vec3First, vec3Second)
  `Get the dot product of the x and y components of a pair of Vector3s.`

getPluralString(number, suffix)
  `Get the plural string.`

getPointPlusSegmentWithLength(length, point, segment)
  `Get point plus a segment scaled to a given length.`

getPointsByHorizontalDictionary(width, xIntersectionsDictionary)
  `Get points from the horizontalXIntersectionsDictionary.`

getPointsByVerticalDictionary(width, xIntersectionsDictionary)
  `Get points from the verticalXIntersectionsDictionary.`

getRadiusArealizedMultiplier(sides)
  `Get the radius multiplier for a polygon of equal area.`

getRandomComplex(begin, end)
  `Get random complex.`

getRank(width)
  `Get the rank which is 0 at 1 and increases by three every power of ten.`

getRotatedComplexLists(planeAngle, pointLists)
  `Get point lists rotated by the plane angle`

getRotatedComplexes(planeAngle, points)
  `Get points rotated by the plane angle`

getRotatedWiddershinsQuarterAroundZAxis(vector3)
  `Get Vector3 rotated a quarter widdershins turn around Z axis.`

getRoundZAxisByPlaneAngle(planeAngle, vector3)
  `Get Vector3 rotated by a plane angle.`

getRoundedPoint(point)
  `Get point with each component rounded.`

getRoundedToPlaces(decimalPlaces, number)
  `Get number rounded to a number of decimal places.`

getRoundedToPlacesString(decimalPlaces, number)
  `Get number rounded to a number of decimal places as a string, without exponential formatting.`

getRoundedToThreePlaces(number)
  `Get number rounded to three places as a string.`

getSegmentFromPath(path, pathIndex)
  `Get endpoint segment from a path.`

getSegmentFromPoints(begin, end)
  `Get endpoint segment from a pair of points.`

getSegmentsFromXIntersectionIndexes(xIntersectionIndexList, y)
  `Get endpoint segments from the x intersection indexes.`

getSegmentsFromXIntersections(xIntersections, y)
  `Get endpoint segments from the x intersections.`

getSimplifiedLoop(loop, radius)
  `Get loop with points inside the channel removed.`

getSimplifiedLoops(loops, radius)
  `Get the simplified loops.`

getSimplifiedPath(path, radius)
  `Get path with points inside the channel removed.`

getSquareIsOccupied(pixelDictionary, x, y)
  `Determine if a square around the x and y pixel coordinates is occupied.`

getSquareLoopWiddershins(beginComplex, endComplex)
  `Get a square loop from the beginning to the end and back.`

getSquareValues(pixelDictionary, x, y)
  `Get a list of the values in a square around the x and y pixel coordinates.`

getSquareValuesFromPoint(pixelDictionary, point)
  `Get a list of the values in a square around the point.`

getStepKeyFromPoint(point)
  `Get step key for the point.`

getThreeSignificantFigures(number)
  `Get number rounded to three significant figures as a string.`

getTopPath(path)
  `Get the top of the path.`

getTopPaths(paths)
  `Get the top of the paths.`

getTransferClosestNestedRing(extrusionHalfWidth, nestedRings, oldOrderedLocation, skein, threadSequence)
  `Get and transfer the closest remaining nested ring.`

getTransferredNestedRings(insides, loop)
  `Get transferred paths from inside nested rings.`

getTransferredPaths(insides, loop)
  `Get transferred paths from inside paths.`

getTranslatedComplexPath(path, translateComplex)
  `Get the translated complex path.`

getVector3Path(complexPath, z=0.0)
  `Get the vector3 path from the complex path.`

getVector3Paths(complexPaths, z=0.0)
  `Get the vector3 paths from the complex paths.`

getWiddershinsUnitPolar(angle)
  `Get polar complex from counterclockwise angle from 1, 0.`

getXIntersectionIfExists(beginComplex, endComplex, y)
  `Get the x intersection if it exists.`

getXIntersectionsFromIntersections(xIntersectionIndexList)
  `Get x intersections from the x intersection index list, in other words subtract non negative intersections from negatives.`

getXYComplexFromVector3(vector3)
  `Get an xy complex from a vector3 if it exists, otherwise return None.`

getYIntersectionIfExists(beginComplex, endComplex, x)
  `Get the y intersection if it exists.`

getZComponentCrossProduct(vec3First, vec3Second)
  `Get z component cross product of a pair of Vector3s.`

isInsideOtherLoops(loopIndex, loops)
  `Determine if a loop in a list is inside another loop in that list.`

isLineIntersectingInsideXSegment(beginComplex, endComplex, segmentFirstX, segmentSecondX, y)
  `Determine if the line is crossing inside the x segment.`

isLineIntersectingLoop(loop, pointBegin, pointEnd)
  `Determine if the line is intersecting loops.`

isLineIntersectingLoops(loops, pointBegin, pointEnd)
  `Determine if the line is intersecting loops.`

isLoopIntersectingInsideXSegment(loop, segmentFirstX, segmentSecondX, segmentYMirror, y)
  `Determine if the loop is intersecting inside the x segment.`

isLoopIntersectingLoop(loop, otherLoop)
  `Determine if the loop is intersecting the other loop.`

isLoopIntersectingLoops(loop, otherLoops)
  `Determine if the loop is intersecting other loops.`

isLoopListIntersecting(loops)
  `Determine if a loop in the list is intersecting the other loops.`

isLoopListIntersectingInsideXSegment(loopList, segmentFirstX, segmentSecondX, segmentYMirror, y)
  `Determine if the loop list is crossing inside the x segment.`

isPathEntirelyInsideLoop(loop, path)
  `Determine if a path is entirely inside another loop.`

isPathEntirelyInsideLoops(loops, path)
  `Determine if a path is entirely inside another loop in a list.`

isPathInsideLoop(loop, path)
  `Determine if a path is inside another loop.`

isPathInsideLoops(loops, path)
  `Determine if a path is inside another loop in a list.`

isPixelTableIntersecting(bigTable, littleTable, maskTable={})
  `Add path to the pixel table.`

isPointInsideLoop(loop, point)
  `Determine if a point is inside another loop.`

isSegmentCompletelyInX(segment, xFirst, xSecond)
  `Determine if the segment overlaps within x.`

isWiddershins(polygonComplex)
  `Determine if the complex polygon goes round in the widdershins direction.`

isWithinChannel(channelRadius, pointIndex, loop)
  `Determine if the the point is within the channel between two adjacent points.`

isXSegmentIntersectingPath(path, segmentFirstX, segmentSecondX, segmentYMirror, y)
  `Determine if a path is crossing inside the x segment.`

isXSegmentIntersectingPaths(paths, segmentFirstX, segmentSecondX, segmentYMirror, y)
  `Determine if a path list is crossing inside the x segment.`

joinSegmentTables(fromTable, intoTable)
  `Join both segment tables and put the join into the intoTable.`

joinXIntersectionsTables(fromTable, intoTable)
  `Join both XIntersections tables and put the join into the intoTable.`

overwriteDictionary(fromDictionary, keys, toDictionary)
  `Overwrite the dictionary.`

removeElementFromDictionary(dictionary, key)
  `Remove element from the dictionary.`

removeElementFromListTable(element, key, listDictionary)
  `Remove an element from the list table.`

removeElementFromPixelListFromPoint(element, pixelDictionary, point)
  `Remove an element from the pixel list.`

removeElementsFromDictionary(dictionary, keys)
  `Remove list from the dictionary.`

removePixelTableFromPixelTable(pixelDictionaryToBeRemoved, pixelDictionaryToBeRemovedFrom)
  `Remove pixel from the pixel table.`

removePrefixFromDictionary(dictionary, prefix)
  `Remove the attributes starting with the prefix from the dictionary.`

removeTrueFromDictionary(dictionary, key)
  `Remove key from the dictionary in the value is true.`

removeTrueListFromDictionary(dictionary, keys)
  `Remove list from the dictionary in the value is true.`

subtractXIntersectionsTable(subtractFromTable, subtractTable)
  `Subtract the subtractTable from the subtractFromTable.`

swapList(elements, indexBegin, indexEnd)
  `Swap the list elements.`

toggleHashtable(hashtable, key, value)
  `Toggle a hashtable between having and not having a key.`

transferClosestFillLoop(extrusionHalfWidth, oldOrderedLocation, remainingFillLoops, skein)
  `Transfer the closest remaining fill loop.`

transferClosestPath(oldOrderedLocation, remainingPaths, skein)
  `Transfer the closest remaining path.`

transferClosestPaths(oldOrderedLocation, remainingPaths, skein)
  `Transfer the closest remaining paths.`

transferPathsToNestedRings(nestedRings, paths)
  `Transfer paths to nested rings.`

translateVector3Path(path, translateVector3)
  `Translate the vector3 path.`

translateVector3Paths(paths, translateVector3)
  `Translate the vector3 paths.`

unbuckleBasis(basis, maximumUnbuckling, normal)
  `Unbuckle space.`

Data

``

__author__ = 'Enrique Perez (perez_enrique@yahoo.com)'
__date__ = '$Date: 2008/21/04 $'
__license__ = 'GNU Affero General Public License http://www.gnu.org/licenses/agpl.html'
absolute_import = _Feature((2, 5, 0, 'alpha', 1), (2, 7, 0, 'alpha', 0), 16384)
globalGoldenAngle = 3.883222077450933
globalGoldenRatio = 1.618033988749895
globalTau = 6.283185307179586

Author
`` |  | Enrique Perez (perez_enrique@yahoo.com)