def orientation(ptfs, polyi):
jbl, ptbl = min(enumerate(ptfs[i] for i in polyi),
key=lambda X: (X[1][1], X[1][0]))
ptblFore = ptfs[polyi[(jbl + 1) % len(polyi)]]
ptblBack = ptfs[polyi[(jbl + len(polyi) - 1) % len(polyi)]]
angFore = P2(ptblFore[0] - ptbl[0], ptblFore[1] - ptbl[1]).Arg()
angBack = P2(ptblBack[0] - ptbl[0], ptblBack[1] - ptbl[1]).Arg()
return (angBack < angFore)
def MakeRectBarmeshForWingParametrization(seval, xpart, ypart):
bm = barmesh.BarMesh()
nxs = xpart.nparts + 1
nodes = bm.nodes
xbars = [] # multiple of nxs
ybars = [] # multiple of nxs-1
for y in ypart.vs:
bfirstrow = (len(nodes) == 0)
for i in range(nxs):
sp = P2(xpart.vs[i], y)
nnode = bm.AddNode(WNode(seval(sp[0], sp[1]), sp, -1))
assert nnode == nodes[-1]
if not bfirstrow:
xbars.append(Bar(nodes[-nxs - 1], nodes[-1]))
bm.bars.append(xbars[-1])
if i != 0:
xbars[-1].barbackleft = ybars[1 - nxs]
ybars[1 - nxs].barbackleft = xbars[-2]
if i != 0:
ybars.append(Bar(nodes[-2], nodes[-1]))
bm.bars.append(ybars[-1])
if not bfirstrow:
ybars[-1].barforeright = xbars[-1]
xbars[-2].barforeright = ybars[-1]
assert len(bm.bars) == len(xbars) + len(ybars)
return bm
def projectpostpen(postpensketch, bupperface):
resuv = []
for g in postpensketch.GeometryFacadeList:
if not g.Construction:
gg = g.Geometry
num = int(math.ceil(gg.length() / legsampleleng) + 1)
params = numpy.linspace(gg.FirstParameter, gg.LastParameter, num)
qs = []
for a in params:
p = gg.value(a)
q = wingeval.inverse_seval(p.x, p.y, bupperface, tol=0.001)
qs.append(P2(q[0], q[1]))
if len(qs) > 2:
resuv.append(qs)
return resuv
def projectdetaillinesF(sporigin, sptriangle, xpart, uvtranslistCcolumns,
uspacing, vspacing, battendetaillines):
cc = findcctriangleinmesh(sptriangle, xpart, uvtranslistCcolumns)
if cc is None:
return []
if abs(cc["cpt"][0] -
sptriangle.u) > uspacing or abs(cc["cpt"][1] -
sptriangle.v) > vspacing:
return []
vc = sporigin - cc["cpt"]
vcp = cc["urvec"] * vc.u + cc["vrvec"] * vc.v
vcs = cc["vj"] * vcp.u + cc["vj1"] * vcp.v # should be same as vc
vcsT = cc["vjT"] * vcp.u + cc["vj1T"] * vcp.v
# use the 6mm expansion on either side of this line to our advantage
ccLeft = findcctriangleinmesh(sptriangle - P2(5, 0), xpart,
uvtranslistCcolumns)
ccRight = findcctriangleinmesh(sptriangle + P2(5, 0), xpart,
uvtranslistCcolumns)
assert ccLeft != None and ccRight != None, (ccLeft, ccRight)
trailingedgevecL = P2.ZNorm(ccLeft["vjT"] * ccLeft["urvec"].u +
ccLeft["vj1T"] * ccLeft["urvec"].v)
trailingedgevecR = P2.ZNorm(ccRight["vjT"] * ccRight["urvec"].u +
ccRight["vj1T"] * ccRight["urvec"].v)
#trailingedgevec = P2.ZNorm(cc["vjT"]*cc["urvec"].u + cc["vj1T"]*cc["urvec"].v)
trailingedgevec = P2.ZNorm(trailingedgevecL + trailingedgevecR)
#print("trailingedge angles ", trailingedgevecL.Arg(), trailingedgevecR.Arg())
trailingedgevecPerp = P2.ZNorm(cc["vjT"] * cc["vrvec"].u +
cc["vj1T"] * cc["vrvec"].v)
#trailingedgevec = P2.CPerp(trailingedgevecPerp)
battendetails = []
for lsp in battendetaillines:
battendetails.append(vcsT + cc["cptT"] + trailingedgevec * lsp.u +
trailingedgevecPerp * lsp.v)
return battendetails
def cpolyuvvectorstransF(uvpts, fptsT, cpoly):
cpt = sum((P2(*uvpts[ci]) for ci in cpoly), P2(0, 0)) * (1.0 / len(cpoly))
cptT = sum((P2(*fptsT[ci]) for ci in cpoly), P2(0, 0)) * (1.0 / len(cpoly))
n = len(cpoly)
jp = max((abs(
P2.Dot((P2(*uvpts[cpoly[j]]) -
cpt), P2.APerp(P2(*uvpts[cpoly[(j + 1) % n]]) - cpt))), j)
for j in range(n))
vj = P2(*uvpts[cpoly[jp[1]]]) - cpt
vj1 = P2(*uvpts[cpoly[(jp[1] + 1) % n]]) - cpt
urvec = P2(vj1.v, -vj.v)
urvec = urvec * (1.0 / P2.Dot(urvec, P2(vj.u, vj1.u)))
vrvec = P2(vj1.u, -vj.u)
vrvec = vrvec * (1.0 / P2.Dot(vrvec, P2(vj.v, vj1.v)))
# this has gotten muddled. Should be simpler since the following two are negative of each other
# P2.Dot(urvec, P2(vj.u, vj1.u)) = vj1.v*vj.u - vj.v*vj1.u
# P2.Dot(vrvec, P2(vj.v, vj1.v)) = vj1.u*vj.v - vj.u*vj1.v
# set solve: (urvec.u*vj + urvec.v*vj1).v = 0, which is why it uses only v components
vjT = P2(*fptsT[cpoly[jp[1]]]) - cptT
vj1T = P2(*fptsT[cpoly[(jp[1] + 1) % n]]) - cptT
# vc = p - cc["cpt"]
#vcp = cc["urvec"]*vc.u + cc["vrvec"]*vc.v
#vcs = cc["vj"]*vcp.u + cc["vj1"]*vcp.v -> vc
return {
"cpt": cpt,
"cptT": cptT,
"urvec": urvec,
"vrvec": vrvec,
"vj": vj,
"vj1": vj1,
"vjT": vjT,
"vj1T": vj1T
}
def applyconsistenrotationtoflats(surfacemesh):
ptsF = surfacemesh["fpts"] * (
1, -1) # reflect in Y using numpy.array multiplication
offsetloopuv = surfacemesh["offsetloopuv"]
offsetloopptsF = [
P2(ptsF[i][0], ptsF[i][1]) for i in surfacemesh["offsetloopI"]
]
offsetloopuvCentre = sum(offsetloopuv, start=P2(
0, 0)) * (1.0 / len(offsetloopuv))
offsetloopptsFCentre = sum(offsetloopptsF, start=P2(
0, 0)) * (1.0 / len(offsetloopptsF))
voff = offsetloopuvCentre - offsetloopptsFCentre
# this proves all the polygons are reflected
orientOrg = orientation(surfacemesh["uvpts"], surfacemesh["offsetloopI"])
orientReflFlatttened = orientation(ptsF, surfacemesh["offsetloopI"])
assert orientOrg == orientReflFlatttened
# try and rotate so we align with the first edge
i0 = surfacemesh["offsetloopI"][-10]
i1 = surfacemesh["offsetloopI"][-5]
if surfacemesh["patchname"] == "US2":
i0 = surfacemesh["offsetloopI"][10]
i1 = surfacemesh["offsetloopI"][15]
if surfacemesh["patchname"] == "TSR":
i0 = surfacemesh["offsetloopI"][150]
i1 = surfacemesh["offsetloopI"][155]
#v = P2(*surfacemesh["uvpts"][i1]) - offsetloopuvCentre
#vF = P2(*ptsF[i1]) - offsetloopptsFCentre
v = P2(*surfacemesh["uvpts"][i1]) - P2(*surfacemesh["uvpts"][i0])
vF = P2(*ptsF[i1]) - P2(*ptsF[i0])
xv = P2.ZNorm(P2(P2.Dot(vF, v), P2.Dot(P2.APerp(vF), v)))
yv = P2.APerp(xv)
explodev = (offsetloopuvCentre - P2(3, 0)) * 0.8
if surfacemesh["patchname"] == "TSM3":
offsetloopuvCentre -= P2(1.0, -0.3)
def transF(p):
p0 = p - offsetloopptsFCentre
return xv * p0[0] + yv * p0[1] + offsetloopuvCentre + explodev
surfacemesh["fptsT"] = fptsT = numpy.array([transF(p) for p in ptsF])
vFT = P2(*surfacemesh["fptsT"][i1]) - P2(*surfacemesh["fptsT"][i0])
#print(v.Arg(), vF.Arg(), vFT.Arg())
surfacemesh["textpos"] = offsetloopuvCentre + explodev
assert ccnode.i != -1
ccpoly.append(ccnode.i)
if ccnode == cnode:
break
ccbar = ccbar.GetForeRightBL(ccbar.nodefore == ccnode)
if not (ccnode.pointzone.izone == cizone):
tbarcycles.remove((ccbar, ccnode))
cpolys.append(ccpoly)
return tnodes, cpolys
def cpolytriangulate(ptsF, cpoly):
if (n := len(cpoly)) == 3:
return [cpoly]
assert n == len(cpoly)
jp = max((min(P2.Dot((ptsF[cpoly[(j+i)%n]]-ptsF[cpoly[j]]), P2.APerp(ptsF[cpoly[(j+i+1)%n]]-ptsF[cpoly[j]])) \
for i in range(1, n-1)), j) for j in range(n))
j = jp[1]
return [(cpoly[j], cpoly[(j + i) % n], cpoly[(j + i + 1) % n])
for i in range(1, n - 1)]
def orientation(ptfs, polyi):
jbl, ptbl = min(enumerate(ptfs[i] for i in polyi),
key=lambda X: (X[1][1], X[1][0]))
ptblFore = ptfs[polyi[(jbl + 1) % len(polyi)]]
ptblBack = ptfs[polyi[(jbl + len(polyi) - 1) % len(polyi)]]
angFore = P2(ptblFore[0] - ptbl[0], ptblFore[1] - ptbl[1]).Arg()
angBack = P2(ptblBack[0] - ptbl[0], ptblBack[1] - ptbl[1]).Arg()
return (angBack < angFore)
def cpolyuvvectorstransC(uvpts, fptsT):
assert len(uvpts) == len(fptsT)
n = len(uvpts)
area = abs(
P2.Dot(fptsT[1] - fptsT[0], P2.APerp(fptsT[2] - fptsT[0])) * 0.5)
uvarea = abs(
P2.Dot(uvpts[1] - uvpts[0], P2.APerp(uvpts[2] - uvpts[0])) * 0.5)
if uvarea == 0:
return {"uvarea": 0.0}
cpt = sum(uvpts, P2(0, 0)) * (1.0 / n)
cptT = sum(fptsT, P2(0, 0)) * (1.0 / n)
jp = max(
(abs(P2.Dot(uvpts[j] - cpt, P2.APerp(uvpts[(j + 1) % n] - cpt))), j)
for j in range(n))
vj = uvpts[jp[1]] - cpt
vj1 = uvpts[(jp[1] + 1) % n] - cpt
urvec = P2(vj1.v, -vj.v)
#if P2.Dot(urvec, P2(vj.u, vj1.u)) == 0:
# print(jp[1], uvpts, uvarea)
urvec = urvec * (1.0 / P2.Dot(urvec, P2(vj.u, vj1.u)))
vrvec = P2(vj1.u, -vj.u)
vrvec = vrvec * (1.0 / P2.Dot(vrvec, P2(vj.v, vj1.v)))
# this has gotten muddled. Should be simpler since the following two are negative of each other
# P2.Dot(urvec, P2(vj.u, vj1.u)) = vj1.v*vj.u - vj.v*vj1.u
# P2.Dot(vrvec, P2(vj.v, vj1.v)) = vj1.u*vj.v - vj.u*vj1.v
# set solve: (urvec.u*vj + urvec.v*vj1).v = 0, which is why it uses only v components
vjT = fptsT[jp[1]] - cptT
vj1T = fptsT[(jp[1] + 1) % n] - cptT
# vc = p - cc["cpt"]
#vcp = cc["urvec"]*vc.u + cc["vrvec"]*vc.v
#vcs = cc["vj"]*vcp.u + cc["vj1"]*vcp.v -> vc
return {
"cpt": cpt,
"cptT": cptT,
"urvec": urvec,
"vrvec": vrvec,
"vj": vj,
"vj1": vj1,
"vjT": vjT,
"vj1T": vj1T,
"area": area,
"uvarea": uvarea
}
def cp2t(t):
return [P2(t[0][0], t[0][1]), P2(t[1][0], t[1][1]), P2(t[2][0], t[2][1])]
# get the batten detail file and set the duplicated positions for the pen cuts
battendetailfile = None if R13type else os.path.join(
os.path.split(__file__)[0], "batten detail TSR.dxf")
#battendetailfile = "/home/julian/repositories/HGnotebooks/wingflattening/freecad_macro_work/batten detail TSR.dxf"
if battendetailfile:
import ezdxf
docbattendetail = ezdxf.readfile(battendetailfile)
dxflines = [
k for k in docbattendetail.entities
if "-CUT" in k.dxf.layer or "PLOT" in k.dxf.layer
]
battendetaillines = []
for line in dxflines:
p0, p1 = P2(line.dxf.start.x,
line.dxf.start.y), P2(line.dxf.end.x, line.dxf.end.y)
battendetaillines.extend([p0, p1])
dxflinelayers = [k.dxf.layer for k in dxflines]
uvoffsettobettertriangle = P2(0, 100)
battonuvdetailpositions = [(P2(u, vrange[0]),
P2(u, vrange[0]) + uvoffsettobettertriangle)
for u in uvals[1:-1]]
def cp2t(t):
return [P2(t[0][0], t[0][1]), P2(t[1][0], t[1][1]), P2(t[2][0], t[2][1])]
def cpolyuvvectorstransC(uvpts, fptsT):
assert len(uvpts) == len(fptsT)
n = len(uvpts)
print("R13 type offsets" if R13type else "P7 wing offsets")
uvpolygons = doc.UVPolygons.OutList
uvpolygonsoffsets = getemptyobject(doc, "App::DocumentObjectGroup", "UVPolygonsOffsets")
uvpolygonsfoldlines = getemptyobject(doc, "App::DocumentObjectGroup", "UVPolygonsFoldlines")
from p7modules.p7wingeval import WingEval
R13type = doc.getObject("Group")
wingeval = WingEval(doc.getObject("Group" if R13type else "SectionGroup").OutList, R13type)
urange, vrange, seval = wingeval.urange, wingeval.vrange, wingeval.seval
from p7modules.barmesh.basicgeo import P2, P3, Partition1, Along, I1
from p7modules.p7wingflatten_barmeshfuncs import polyloopvedgeseqpolyline, polylinewithinsurfaceoffset
surfacemeshdict = dict((uvpoly.Name[1:], [ P2(v.Point.x, v.Point.y) for v in uvpoly.Shape.OrderedVertexes ]) for uvpoly in uvpolygons)
#####scratch work
#uvpoly = doc.UVPolygons.OutList[0]
#polyloop = [ P2(v.Point.x, v.Point.y) for v in uvpoly.Shape.OrderedVertexes ]
#[ i for i in range(len(polyloop)) if polyloop[i].v == 0 ], len(polyloop)
##for patchname, irot, vedge, rad, spstep, spliceloop in offsetstretchcomponents:
#irot = -10
#Dpolyloop = polyloop[irot:] + polyloop[:irot]
#[ i for i in range(len(Dpolyloop)) if Dpolyloop[i].v == 0 ], len(Dpolyloop)
#####
legsampleleng = 3.0
# Use this to check what the extended bspline contour looks like 20 units off either end
#import numpy