suzanne.soy/Lattice2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[Breaking] Linear Array: use common generator code

Browse Source 
Plus, changes to generator code
This commit is contained in:
DeepSOIC 2015-12-20 21:14:26 +03:00
parent e81edc1639
commit 8f7de2e9eb
2 changed files with 81 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

132
lattice2LinearArray.py
View File

@ -34,6 +34,7 @@ from lattice2Common import *
import lattice2BaseFeature
import lattice2Executer
import lattice2GeomUtils
from lattice2ValueSeriesGenerator import ValueSeriesGenerator
def makeLinearArray(name):
'''makeLinearArray(name): makes a LinearArray object.'''
@ -43,24 +44,7 @@ class LinearArray(lattice2BaseFeature.LatticeFeature):
"The Lattice LinearArray object"
def derivedInit(self,obj):
self.Type = "LatticeLinearArray"
obj.addProperty("App::PropertyEnumeration","Mode","Lattice Array","")
obj.Mode = ['SpanN','StepN','SpanStep','Spreadsheet']
obj.Mode = 'StepN'
obj.addProperty("App::PropertyLength","SpanStart","Lattice Array","starting position value.")
obj.addProperty("App::PropertyLength","SpanEnd","Lattice Array","ending position value")
obj.addProperty("App::PropertyBool","EndInclusive","Lattice Array","Determines if the last occurence is placed exactly at the ending position of the span, or the ending position is that of super-last item.")
obj.EndInclusive = True
obj.addProperty("App::PropertyLength","Step","Lattice Array","Distance between occurences")
obj.Step = 3.0
obj.addProperty("App::PropertyInteger","NumberLinear","Lattice Array","Number of occurences")
obj.NumberLinear = 5
obj.addProperty("App::PropertyFloat","Offset","Lattice Array","Offset of the first item (in fractions of step).")
obj.addProperty("App::PropertyVector","Dir","Lattice Array","Vector that defines axis direction")
obj.Dir = App.Vector(1,0,0)
@ -68,43 +52,56 @@ class LinearArray(lattice2BaseFeature.LatticeFeature):
obj.addProperty("App::PropertyLink","Link","Lattice Array","Link to the axis (Edge1 is used for the axis).")
obj.addProperty("App::PropertyString","LinkSubelement","Lattice Array","subelement to take from axis link shape")
obj.addProperty("App::PropertyBool","Reverse","Lattice Array","Set to true to reverse direction")
obj.addProperty("App::PropertyBool","DirIsDriven","Lattice Array","If True, Dir property is driven by link.")
obj.DirIsDriven = True
obj.addProperty("App::PropertyBool","PointIsDriven","Lattice Array","If True, AxisPoint is not updated based on the link.")
obj.PointIsDriven = True
obj.addProperty("App::PropertyEnumeration","DrivenProperty","Lattice Array","Select, which property is to be driven by length of axis link.")
obj.DrivenProperty = ['None','Span','SpanStart','SpanEnd','Step']
obj.DrivenProperty = 'Step'
obj.addProperty("App::PropertyLink","SpreadSheet","SpreadSheet mode","Link to spreadsheet")
obj.addProperty("App::PropertyString","CellStart","SpreadSheet mode","Starting cell of list of positions")
obj.CellStart = 'A1'
obj.addProperty("App::PropertyEnumeration","OrientMode","Lattice Array","Orientation of elements")
obj.OrientMode = ['None','Along axis']
obj.OrientMode = 'Along axis'
def updateReadOnlyness(self, obj):
m = obj.Mode
obj.setEditorMode("Step", 1 if m == "SpanN" or m == "Spreadsheet" else 0)
obj.setEditorMode("SpanEnd", 1 if m == "StepN" or m == "Spreadsheet" else 0)
obj.setEditorMode("NumberLinear", 1 if m == "SpanStep" or m == "Spreadsheet" else 0)
self.assureGenerator(obj)
obj.ValuesSource = "Generator"
obj.EndInclusive = True
obj.SpanStart = 0.0
obj.SpanEnd = 12.0
obj.Step = 3.0
obj.Count = 5.0
def updateReadonlyness(self, obj):
obj.setEditorMode("Dir", 1 if (obj.Link and obj.DirIsDriven) else 0)
obj.setEditorMode("Point", 1 if (obj.Link and not obj.PointIsDriven) else 0)
obj.setEditorMode("DirIsDriven", 0 if obj.Link else 1)
obj.setEditorMode("PointIsDriven", 0 if obj.Link else 1)
obj.setEditorMode("DrivenProperty", 0 if obj.Link else 1)
obj.setEditorMode("SpreadSheet", 0 if m == "Spreadsheet" else 1)
obj.setEditorMode("CellStart", 0 if m == "Spreadsheet" else 1)
self.generator.updateReadonlyness()
def assureGenerator(self, obj):
'''Adds an instance of value series generator, if one doesn't exist yet.'''
if hasattr(self,"generator"):
return
self.generator = ValueSeriesGenerator(obj)
self.generator.addProperties(groupname= "Lattice Array",
groupname_gen= "Lattice Series Generator",
valuesdoc= "List of parameter values to compute object for.",
valuestype= "App::PropertyDistance")
self.updateReadonlyness(obj)
def derivedExecute(self,obj):
self.updateReadOnlyness(obj)
self.assureGenerator(obj)
self.updateReadonlyness(obj)
# Apply links
if obj.Link:
@ -133,42 +130,18 @@ class LinearArray(lattice2BaseFeature.LatticeFeature):
obj.Point = point
if obj.DrivenProperty != 'None':
if obj.DrivenProperty == 'Span':
propname = "SpanEnd"
obj.SpanEnd = obj.SpanStart + App.Units.Quantity('mm')*dir.Length
else:
setattr(obj, obj.DrivenProperty, dir.Length)
propname = obj.DrivenProperty
setattr(obj, propname, dir.Length)
if obj.generator.isPropertyControlledByGenerator(propname):
lattice2executer.warning(obj, "Property "+propname+" is driven by both generator and link. Generator has priority.")
# Fill in (update read-only) properties that are driven by the mode.
if obj.Mode == 'SpanN':
n = obj.NumberLinear
if obj.EndInclusive:
n -= 1
if n == 0:
n = 1
obj.Step = (obj.SpanEnd - obj.SpanStart)/n
if obj.DrivenProperty == 'Step' and obj.Link:
lattice2Executer.warning(obj,"Step property is being driven by both the link and the selected mode. Mode has priority.")
elif obj.Mode == 'StepN':
n = obj.NumberLinear
if obj.EndInclusive:
n -= 1
obj.SpanEnd = obj.SpanStart + obj.Step*n
if 'Span' in obj.DrivenProperty and obj.Link:
lattice2Executer.warning(obj,"SpanEnd property is being driven by both the link and the selected mode. Mode has priority.")
elif obj.Mode == 'SpanStep':
nfloat = float((obj.SpanEnd - obj.SpanStart) / obj.Step)
n = math.trunc(nfloat - ParaConfusion) + 1
if obj.EndInclusive and abs(nfloat-round(nfloat)) <= ParaConfusion:
n = n + 1
obj.NumberLinear = n
# Generate the actual array. We can use Step and N directly to
# completely avoid mode logic, since we had updated them
# cache properties into variables
step = float(obj.Step)
start = float(obj.SpanStart) + step*float(obj.Offset)
n = int(obj.NumberLinear)
# Generate series of values
self.generator.execute()
values = [float(strv) for strv in obj.Values]
#Apply reversal
if obj.Reverse:
@ -188,31 +161,8 @@ class LinearArray(lattice2BaseFeature.LatticeFeature):
# Make the array
output = [] # list of placements
if obj.Mode != "Spreadsheet":
for i in range(0, n):
position = start + step*i
output.append( App.Placement(obj.Point + obj.Dir*position, ori) )
else:
#parse address
addr = obj.CellStart
#assuming only two letter column
if addr[1].isalpha():
col = addr[0:2]
row = addr[2:]
else:
col = addr[0:1]
row = addr[1:]
row = int(row)
#loop until the value can't be read out
while True:
try:
position = obj.SpreadSheet.get(col+str(row))
except ValueError:
break
position = float(position)
output.append( App.Placement(obj.Point + obj.Dir*position, ori) )
row += 1
for v in values:
output.append( App.Placement(obj.Point + obj.Dir*v, ori) )
return output

58
lattice2ValueSeriesGenerator.py
View File

@ -38,7 +38,7 @@ class ValueSeriesGenerator:
self.gen_laws = ['Linear','Exponential']
self.readonlynessDict = {}
def addProperties(self, groupname, groupname_gen, valuesdoc):
def addProperties(self, groupname, groupname_gen, valuesdoc, valuestype = 'App::PropertyFloat'):
# _addProperty(proptype , propname , defvalue, group, tooltip)
self._addProperty("App::PropertyStringList" ,"Values" , None, groupname, valuesdoc)
self._addProperty("App::PropertyEnumeration","ValuesSource" , self.source_modes, groupname, "Select where to take the value series from.")
@ -48,10 +48,10 @@ class ValueSeriesGenerator:
self._addProperty("App::PropertyEnumeration","GeneratorMode" , self.gen_modes, groupname_gen,"")
self._addProperty("App::PropertyEnumeration","DistributionLaw", self.gen_laws, groupname_gen,"")
self._addProperty("App::PropertyFloat" ,"SpanStart" , 1.0, groupname_gen, "Starting value for value series generator")
self._addProperty("App::PropertyFloat" ,"SpanEnd" , 7.0, groupname_gen, "Ending value for value series generator")
self._addProperty(valuestype ,"SpanStart" , 1.0, groupname_gen, "Starting value for value series generator")
self._addProperty(valuestype ,"SpanEnd" , 7.0, groupname_gen, "Ending value for value series generator")
self._addProperty("App::PropertyBool" ,"EndInclusive" , True, groupname_gen, "If True, the last value in series will equal SpanEnd. If False, the value equal to SpanEnd will be dropped.")
self._addProperty("App::PropertyFloat" ,"Step" , 1.0, groupname_gen, "Step for value generator. For exponential law, it is a natural logarithm of change ratio.")
self._addProperty("App::PropertyFloat" ,"Step" , 1.0, groupname_gen, "Step for value generator. For exponential law, it is a natural logarithm of change ratio.") # using float for Step, because step's unit depends n selected distribution law
self._addProperty("App::PropertyFloat" ,"Count" , 7.0, groupname_gen, "Number of values to generate")
def _addProperty(self, proptype, propname, defvalue, group, tooltip):
@ -65,21 +65,42 @@ class ValueSeriesGenerator:
obj = self.documentObject
m = obj.GeneratorMode
src = obj.ValuesSource
genOn = obj.ValuesSource == "Generator"
self._setPropertyWritable("Values" , src == "Values Property" )
self._setPropertyWritable("ValuesSource" , True )
self._setPropertyWritable("SpreadsheetLink" , src == "Spreadsheet" )
self._setPropertyWritable("CellStart" , src == "Spreadsheet" )
self._setPropertyWritable("GeneratorMode" , genOn )
self._setPropertyWritable("DistributionLaw" , genOn )
self._setPropertyWritable("SpanStart" , genOn )
self._setPropertyWritable("SpanEnd" , genOn and not(m == "StepN") )
self._setPropertyWritable("EndInclusive" , genOn )
self._setPropertyWritable("Step" , genOn and not(m == "SpanN" or m == "Random"))
self._setPropertyWritable("Count" , genOn and not(m == "SpanStep") )
self._setPropertyWritable("GeneratorMode" , not self.isPropertyControlledByGenerator("GeneratorMode" ) )
self._setPropertyWritable("DistributionLaw" , not self.isPropertyControlledByGenerator("DistributionLaw") )
self._setPropertyWritable("SpanStart" , not self.isPropertyControlledByGenerator("SpanStart" ) )
self._setPropertyWritable("SpanEnd" , not self.isPropertyControlledByGenerator("SpanEnd" ) )
self._setPropertyWritable("EndInclusive" , not self.isPropertyControlledByGenerator("EndInclusive" ) )
self._setPropertyWritable("Step" , not self.isPropertyControlledByGenerator("Step" ) )
self._setPropertyWritable("Count" , not self.isPropertyControlledByGenerator("Count" ) )
def isPropertyControlledByGenerator(self, propname):
obj = self.documentObject
if not hasattr(obj, propname):
raise AttributeError(obj.Name+": has no property named "+propname)
m = obj.GeneratorMode
genOn = obj.ValuesSource == "Generator"
if not genOn:
return False
if propname == "SpanStart":
return False
elif propname == "SpanEnd":
return m == "StepN"
elif propname == "Step":
return m == "SpanN"
elif propname == "Count":
return m == "SpanStep"
else:
return False
def setPropertyWritable(self, propname, bool_writable):
'''setPropertyWritable(self, propname, bool_writable): Use to force a property read-only
@ -89,8 +110,6 @@ class ValueSeriesGenerator:
def _setPropertyWritable(self, propname, bool_writable, suppress_warning = False):
if self.readonlynessDict.has_key(propname):
if bool_writable == False and self.readonlynessDict[propname] == False and not suppress_warning:
lattice2Executer.warning(self.documentObject, "Property "+propname+" is being driven by generator, and something else (e.g., a link). Generator has priority.")
bool_writable = bool_writable and self.readonlynessDict[propname]
self.documentObject.setEditorMode(propname, 0 if bool_writable else 1)
@ -104,12 +123,14 @@ class ValueSeriesGenerator:
if obj.DistributionLaw == 'Linear':
vStart = float(obj.SpanStart)
vEnd = float(obj.SpanEnd)
vStep = float(obj.Step)
elif obj.DistributionLaw == 'Exponential':
vSign = 1 if obj.SpanStart > 0.0 else -1.0
vStart = math.log(obj.SpanStart * vSign)
if obj.SpanEnd * vSign < ParaConfusion:
raise ValueError(obj.Name+": Wrong SpanEnd value. It is either zero, or of different sign compared to SpanStart. In exponential distribution, it is not allowed.")
vEnd = math.log(obj.SpanEnd * vSign)
vStep = float(obj.Step)
else:
raise ValueError(obj.Name+": distribution law not implemented: "+obj.DistributionLaw)
@ -119,12 +140,13 @@ class ValueSeriesGenerator:
n -= 1
if n == 0:
n = 1
obj.Step = (vEnd - vStart)/n
vStep = (vEnd - vStart)/n
obj.Step = vStep
elif obj.GeneratorMode == 'StepN':
n = obj.Count
if obj.EndInclusive:
n -= 1
vEnd = vStart + obj.Step*n
vEnd = vStart + float(vStep)*n
if obj.DistributionLaw == 'Linear':
obj.SpanEnd = vEnd
elif obj.DistributionLaw == 'Exponential':
@ -132,7 +154,7 @@ class ValueSeriesGenerator:
else:
raise ValueError(obj.Name+": distribution law not implemented: "+obj.DistributionLaw)
elif obj.GeneratorMode == 'SpanStep':
nfloat = float((vEnd - vStart) / obj.Step)
nfloat = float((vEnd - vStart) / vStep)
n = math.trunc(nfloat - ParaConfusion) + 1
if obj.EndInclusive and abs(nfloat-round(nfloat)) <= ParaConfusion:
n = n + 1