ExtrusionEntityCollection
PerimeterGenerator::_fill_gaps(double min, double max, double w,
const Polygons &gaps) const
{
ExtrusionEntityCollection coll;
min *= (1 - INSET_OVERLAP_TOLERANCE);
ExPolygons curr = diff_ex(
offset2(gaps, -min/2, +min/2),
offset2(gaps, -max/2, +max/2),
true
);
Polylines polylines;
for (ExPolygons::const_iterator ex = curr.begin(); ex != curr.end(); ++ex)
ex->medial_axis(max, min/2, &polylines);
if (polylines.empty())
return coll;
#ifdef SLIC3R_DEBUG
if (!curr.empty())
printf(" %zu gaps filled with extrusion width = %f\n", curr.size(), w);
#endif
//my $flow = $layerm->flow(FLOW_ROLE_SOLID_INFILL, 0, $w);
Flow flow(
w, this->layer_height, this->solid_infill_flow.nozzle_diameter
);
double mm3_per_mm = flow.mm3_per_mm();
for (Polylines::const_iterator p = polylines.begin(); p != polylines.end(); ++p) {
ExtrusionPath path(erGapFill);
path.polyline = *p;
path.mm3_per_mm = mm3_per_mm;
path.width = flow.width;
path.height = this->layer_height;
if (p->is_valid() && p->first_point().coincides_with(p->last_point())) {
// since medial_axis() now returns only Polyline objects, detect loops here
ExtrusionLoop loop;
loop.paths.push_back(path);
coll.append(loop);
} else {
coll.append(path);
}
}
return coll;
}
TEST_F(DisplayItemPropertyTreeBuilderTest, Nested2DTranslation)
{
FloatSize offset1(10, -40);
TransformationMatrix translation1;
translation1.translate(offset1.width(), offset1.height());
FloatSize offset2(80, 80);
TransformationMatrix translation2;
translation2.translate(offset2.width(), offset2.height());
// These drawings should share a transform node but have different range
// record offsets.
processDummyDisplayItem();
auto transform1 = processBeginTransform3D(translation1);
processDummyDisplayItem();
auto transform2 = processBeginTransform3D(translation2);
processDummyDisplayItem();
processEndTransform3D(transform2);
processEndTransform3D(transform1);
finishPropertyTrees();
// There should only be a root transform node.
ASSERT_EQ(1u, transformTree().nodeCount());
EXPECT_TRUE(transformTree().nodeAt(0).isRoot());
// Check that the range records have the right offsets.
EXPECT_THAT(rangeRecordsAsStdVector(), ElementsAre(
AllOf(hasRange(0, 1), hasTransformNode(0), hasOffset(FloatSize())),
AllOf(hasRange(2, 3), hasTransformNode(0), hasOffset(offset1)),
AllOf(hasRange(4, 5), hasTransformNode(0), hasOffset(offset1 + offset2))));
}
Slic3r::ExPolygons
offset2_ex(const Slic3r::Polygons &polygons, const float delta1,
const float delta2, const ClipperLib::JoinType joinType, const double miterLimit)
{
Slic3r::ExPolygons expp;
offset2(polygons, &expp, delta1, delta2, joinType, miterLimit);
return expp;
}
void qxgeditScale::setOffset2 ( unsigned short iOffset2 )
{
if (m_iOffset2 != iOffset2) {
m_iOffset2 = iOffset2;
update();
emit offset2Changed(offset2());
}
}
void
offset2(const Slic3r::Polygons &polygons, Slic3r::ExPolygons* retval, const float delta1,
const float delta2, const double scale, const ClipperLib::JoinType joinType, const double miterLimit)
{
// perform offset
ClipperLib::Paths output;
offset2(polygons, &output, delta1, delta2, scale, joinType, miterLimit);
// convert into ExPolygons
ClipperPaths_to_Slic3rExPolygons(output, retval);
}
void
offset2_ex(const Slic3r::Polygons &polygons, Slic3r::ExPolygons &retval, const float delta1,
const float delta2, const double scale, const ClipperLib::JoinType joinType, const double miterLimit)
{
// perform offset
ClipperLib::Paths* output = new ClipperLib::Paths();
offset2(polygons, *output, delta1, delta2, scale, joinType, miterLimit);
// convert into ExPolygons
ClipperPaths_to_Slic3rExPolygons(*output, retval);
delete output;
}
void CPlayerStateSwim_WaterTestProxy::DebugDraw(const CPlayer& player, const Vec3& referencePosition)
{
// DEBUG RENDERING
const SPlayerStats& stats = *player.GetActorStats();
const bool debugSwimming = (g_pGameCVars->cl_debugSwimming != 0);
if (debugSwimming && (m_playerWaterLevel > -10.0f) && (m_playerWaterLevel < 10.0f))
{
const Vec3 surfacePosition(referencePosition.x, referencePosition.y, m_waterLevel);
const Vec3 vRight(player.GetBaseQuat().GetColumn0());
const static ColorF referenceColor(1,1,1,1);
const static ColorF surfaceColor1(0,0.5f,1,1);
const static ColorF surfaceColor0(0,0,0.5f,0);
const static ColorF bottomColor(0,0.5f,0,1);
gEnv->pRenderer->GetIRenderAuxGeom()->DrawSphere(referencePosition, 0.1f, referenceColor);
gEnv->pRenderer->GetIRenderAuxGeom()->DrawLine(referencePosition, surfaceColor1, surfacePosition, surfaceColor1, 2.0f);
gEnv->pRenderer->GetIRenderAuxGeom()->DrawSphere(surfacePosition, 0.2f, surfaceColor1);
gEnv->pRenderer->DrawLabel(referencePosition + vRight * 0.5f, 1.5f, "WaterLevel %3.2f (Head underwater: %d)", m_playerWaterLevel, m_headUnderwater ? 1 : 0);
const static int lines = 16;
const static float radius0 = 0.5f;
const static float radius1 = 1.0f;
const static float radius2 = 2.0f;
for (int i = 0; i < lines; ++i)
{
float radians = ((float)i / (float)lines) * gf_PI2;
Vec3 offset0(radius0 * cos_tpl(radians), radius0 * sin_tpl(radians), 0);
Vec3 offset1(radius1 * cos_tpl(radians), radius1 * sin_tpl(radians), 0);
Vec3 offset2(radius2 * cos_tpl(radians), radius2 * sin_tpl(radians), 0);
gEnv->pRenderer->GetIRenderAuxGeom()->DrawLine(surfacePosition+offset0, surfaceColor0, surfacePosition+offset1, surfaceColor1, 2.0f);
gEnv->pRenderer->GetIRenderAuxGeom()->DrawLine(surfacePosition+offset1, surfaceColor1, surfacePosition+offset2, surfaceColor0, 2.0f);
}
if (m_bottomLevel > 0.0f)
{
const Vec3 bottomPosition(referencePosition.x, referencePosition.y, m_bottomLevel);
gEnv->pRenderer->GetIRenderAuxGeom()->DrawLine(referencePosition, bottomColor, bottomPosition, bottomColor, 2.0f);
gEnv->pRenderer->GetIRenderAuxGeom()->DrawSphere(bottomPosition, 0.2f, bottomColor);
gEnv->pRenderer->DrawLabel(bottomPosition + Vec3(0,0,0.5f) - vRight * 0.5f, 1.5f, "BottomDepth %3.3f", m_waterLevel - m_bottomLevel);
}
}
}
bool
Overlap::exceeds(const Slice& slice1a, const Slice& slice1b, const Slice& slice2, double value) {
/**
* First, compute the upper bound for the slice overlap based on the
* bounding boxes.
*/
// values to add to slice2's pixel positions
util::point<int, 2> offset2(0, 0);
// ...only non-zero if we want to align slice2 to both slice1s
if (_align) {
// the mean pixel location of slice1a and slice1b
util::point<double, 2> center1 =
(slice1a.getComponent()->getCenter()*slice1a.getComponent()->getSize()
+
slice1b.getComponent()->getCenter()*slice1b.getComponent()->getSize())
/
(double)(slice1a.getComponent()->getSize() + slice1b.getComponent()->getSize());
offset2 = center1 - slice2.getComponent()->getCenter();
}
util::box<double, 2> bb_intersection_a = slice1a.getComponent()->getBoundingBox().intersection(slice2.getComponent()->getBoundingBox() + offset2);
util::box<double, 2> bb_intersection_b = slice1b.getComponent()->getBoundingBox().intersection(slice2.getComponent()->getBoundingBox() + offset2);
double maxOverlap = bb_intersection_a.area() + bb_intersection_b.area();
if (_normalized)
maxOverlap = normalize(slice1a, slice1b, slice2, maxOverlap);
/**
* If this exceeds the threshold, perform the exact computation of the
* overlap.
*/
if (maxOverlap <= value)
return false;
return (*this)(slice1a, slice1b, slice2) > value;
}
double
Overlap::operator()(const Slice& slice1a, const Slice& slice1b, const Slice& slice2) {
// values to add to slice2's pixel positions
util::point<int, 2> offset2(0, 0);
// ...only non-zero if we want to align slice2 to both slice1s
if (_align) {
// the mean pixel location of slice1a and slice1b
util::point<double, 2> center1 =
(slice1a.getComponent()->getCenter()*slice1a.getComponent()->getSize()
+
slice1b.getComponent()->getCenter()*slice1b.getComponent()->getSize())
/
(double)(slice1a.getComponent()->getSize() + slice1b.getComponent()->getSize());
offset2 = center1 - slice2.getComponent()->getCenter();
}
unsigned int numOverlapa = overlap(
*slice1a.getComponent(),
*slice2.getComponent(),
offset2);
unsigned int numOverlapb = overlap(
*slice1b.getComponent(),
*slice2.getComponent(),
offset2);
unsigned int numOverlap = numOverlapa + numOverlapb;
if (_normalized) {
return normalize(slice1a, slice1b, slice2, numOverlap);
} else {
return numOverlap;
}
}
void Diagcat::evaluateMX(const MXPtrV& input, MXPtrV& output, const MXPtrVV& fwdSeed,
MXPtrVV& fwdSens, const MXPtrVV& adjSeed, MXPtrVV& adjSens,
bool output_given) {
int nfwd = fwdSens.size();
int nadj = adjSeed.size();
// Non-differentiated output
if (!output_given) {
*output[0] = diagcat(getVector(input));
}
// Forward sensitivities
for (int d = 0; d<nfwd; ++d) {
*fwdSens[d][0] = diagcat(getVector(fwdSeed[d]));
}
// Quick return?
if (nadj==0) return;
// Get offsets for each row and column
vector<int> offset1(ndep()+1, 0);
vector<int> offset2(ndep()+1, 0);
for (int i=0; i<ndep(); ++i) {
int ncol = dep(i).sparsity().size2();
int nrow = dep(i).sparsity().size1();
offset2[i+1] = offset2[i] + ncol;
offset1[i+1] = offset1[i] + nrow;
}
// Adjoint sensitivities
for (int d=0; d<nadj; ++d) {
MX& aseed = *adjSeed[d][0];
vector<MX> s = diagsplit(aseed, offset1, offset2);
aseed = MX();
for (int i=0; i<ndep(); ++i) {
adjSens[d][i]->addToSum(s[i]);
}
}
}
bool
Overlap::exceeds(const Slice& slice1, const Slice& slice2, double value, double& exceededValue) {
/**
* First, compute the upper bound for the slice overlap based on the
* bounding boxes.
*/
// values to add to slice2's pixel positions
util::point<int, 2> offset2(0, 0);
// ...only non-zero if we want to align both slices
if (_align)
offset2 = slice1.getComponent()->getCenter() - slice2.getComponent()->getCenter();
util::box<double, 2> bb_intersection = slice1.getComponent()->getBoundingBox().intersection(slice2.getComponent()->getBoundingBox() + offset2);
double maxOverlap = bb_intersection.area();
if (_normalized)
maxOverlap = normalize(slice1, slice2, maxOverlap);
/**
* If this exceeds the threshold, perform the exact computation of the
* overlap.
*/
if (maxOverlap <= value) {
exceededValue = value;
return false;
}
exceededValue = (*this)(slice1, slice2);
return exceededValue > value;
}
double
Overlap::operator()(const Slice& slice1, const Slice& slice2) {
// values to add to slice2's pixel positions
util::point<int, 2> offset2(0, 0);
// ...only non-zero if we want to align both slices
if (_align)
offset2 = slice1.getComponent()->getCenter() - slice2.getComponent()->getCenter();
unsigned int numOverlap = overlap(
*slice1.getComponent(),
*slice2.getComponent(),
offset2);
if (_normalized) {
return normalize(slice1, slice2, numOverlap);
} else {
return numOverlap;
}
}
void BigDoxieNoFeet::addSegments(tgStructure& puppy, tgStructure& vertebra, tgStructure& hip, tgStructure& leg, tgStructure& foot,
double r){
const double offsetDist = r+1;
const double offsetDist2 = offsetDist*8;
const double offsetDist3 = offsetDist2+4;
const double yOffset_leg = -(2*r+1);
const double yOffset_foot = -(2*r+6);
//Vertebrae
btVector3 offset(offsetDist,0.0,0);
//Hips
btVector3 offset1(offsetDist*2,0.0,offsetDist);
btVector3 offset2(offsetDist2,0.0,offsetDist);
btVector3 offset3(offsetDist*2,0.0,-offsetDist);
btVector3 offset4(offsetDist2,0.0,-offsetDist);
//Lower legs
btVector3 offset5(offsetDist3,yOffset_leg,offsetDist);
btVector3 offset6(offsetDist3,yOffset_leg,-offsetDist);
btVector3 offset7(r*2,yOffset_leg,offsetDist);
btVector3 offset8(r*2,yOffset_leg,-offsetDist);
//Feet
btVector3 offset9(offsetDist3+1,yOffset_foot,offsetDist);
btVector3 offset10(offsetDist3+1,yOffset_foot,-offsetDist);
btVector3 offset11(r*2+1,yOffset_foot,offsetDist);
btVector3 offset12(r*2+1,yOffset_foot,-offsetDist);
for(std::size_t i = 0; i < m_segments; i++) { //Connect segments for spine of puppy
tgStructure* t = new tgStructure (vertebra);
t->addTags(tgString("spine segment num", i + 1));
t->move((i + 1)*offset);
if (i % 2 == 1){
t->addRotation(btVector3((i + 1) * offsetDist, 0.0, 0.0), btVector3(1, 0, 0), 0.0);
}
else{
t->addRotation(btVector3((i + 1) * offsetDist, 0.0, 0.0), btVector3(1, 0, 0), M_PI/2.0);
}
puppy.addChild(t); //Add a segment to the puppy
}
for(std::size_t i = m_segments; i < (m_segments + 2); i++) {//deal with right hip and shoulder first
tgStructure* t = new tgStructure (hip);
t->addTags(tgString("segment num", i + 1));
if(i % 2 == 0){
t->move(offset2);
t->addRotation(btVector3(offsetDist2, 0.0, offsetDist), btVector3(0, 1, 0), M_PI);
}
else{
t->move(offset1);
t->addRotation(btVector3(offsetDist*2, 0.0, offsetDist), btVector3(0, 1, 0), M_PI);
}
puppy.addChild(t); //Add a segment to the puppy
}
for(std::size_t i = (m_segments + 2); i < (m_segments + m_hips); i++) {//deal with left hip and shoulder now
tgStructure* t = new tgStructure (hip);
t->addTags(tgString("segment num", i + 1));
if(i % 2 == 0){
t->move(offset4);
}
else{
t->move(offset3);
}
puppy.addChild(t); //Add a segment to the puppy
}
for(std::size_t i = (m_segments + m_hips); i < (m_segments + m_hips + 2); i++) {//right front and back legs
tgStructure* t = new tgStructure (leg);
t->addTags(tgString("segment num", i + 1));
if(i % 2 == 0){
t->move(offset5);
t->addRotation(btVector3(offsetDist3, yOffset_leg, offsetDist), btVector3(0, 1, 0), M_PI);
}
else{
t->move(offset7);
t->addRotation(btVector3(r*2, yOffset_leg, offsetDist), btVector3(0, 1, 0), M_PI);
//the rotations for the legs are a remnant of the earlier design. Removing them now
//would mean changing all my muscle attachments. I will do this someday.
}
puppy.addChild(t); //Add a segment to the puppy
}
for(std::size_t i = (m_segments + m_hips + 2); i < (m_segments + m_hips + m_legs); i++) {//left front and back legs
tgStructure* t = new tgStructure (leg);
t->addTags(tgString("segment num", i + 1));
if(i % 2 == 0){
t->move(offset6);
t->addRotation(btVector3(offsetDist3, yOffset_leg, -offsetDist), btVector3(0, 1, 0), M_PI);
}
else{
t->move(offset8);
t->addRotation(btVector3(r*2, yOffset_leg, -offsetDist), btVector3(0, 1, 0), M_PI);
}
puppy.addChild(t); //Add a segment to the puppy
}
/*for(std::size_t i = (m_segments + m_hips + m_legs); i < (m_segments + m_hips + m_legs + 2); i++) {//right front and back feet
tgStructure* t = new tgStructure (foot);
t->addTags(tgString("segment num", i + 1));
if(i % 2 == 0){
t->move(offset9);
t->addRotation(btVector3(offsetDist3+1, yOffset_foot, offsetDist), btVector3(0, 1, 0), 0.0);
}
else{
t->move(offset11);
t->addRotation(btVector3(r*2+1, yOffset_foot, offsetDist), btVector3(0, 1, 0), 0.0);
}
puppy.addChild(t); //Add a segment to the puppy
}
for(std::size_t i = (m_segments + m_hips + m_legs + 2); i < (m_segments + m_hips + m_legs + m_feet); i++) {//left front and back feet
tgStructure* t = new tgStructure (foot);
t->addTags(tgString("segment num", i + 1));
if(i % 2 == 0){
t->move(offset10);
t->addRotation(btVector3(offsetDist3+1, yOffset_foot, -offsetDist), btVector3(0, 1, 0), 0.0);
}
else{
t->move(offset12);
t->addRotation(btVector3(r*2+1, yOffset_foot, -offsetDist), btVector3(0, 1, 0), 0.0);
}
puppy.addChild(t); //Add a segment to the puppy
} */
}
void
PerimeterGenerator::process()
{
// other perimeters
this->_mm3_per_mm = this->perimeter_flow.mm3_per_mm();
coord_t pwidth = this->perimeter_flow.scaled_width();
coord_t pspacing = this->perimeter_flow.scaled_spacing();
// external perimeters
this->_ext_mm3_per_mm = this->ext_perimeter_flow.mm3_per_mm();
coord_t ext_pwidth = this->ext_perimeter_flow.scaled_width();
coord_t ext_pspacing = this->ext_perimeter_flow.scaled_spacing();
coord_t ext_pspacing2 = this->ext_perimeter_flow.scaled_spacing(this->perimeter_flow);
// overhang perimeters
this->_mm3_per_mm_overhang = this->overhang_flow.mm3_per_mm();
// solid infill
coord_t ispacing = this->solid_infill_flow.scaled_spacing();
coord_t gap_area_threshold = pwidth * pwidth;
// Calculate the minimum required spacing between two adjacent traces.
// This should be equal to the nominal flow spacing but we experiment
// with some tolerance in order to avoid triggering medial axis when
// some squishing might work. Loops are still spaced by the entire
// flow spacing; this only applies to collapsing parts.
// For ext_min_spacing we use the ext_pspacing calculated for two adjacent
// external loops (which is the correct way) instead of using ext_pspacing2
// which is the spacing between external and internal, which is not correct
// and would make the collapsing (thus the details resolution) dependent on
// internal flow which is unrelated.
coord_t min_spacing = pspacing * (1 - INSET_OVERLAP_TOLERANCE);
coord_t ext_min_spacing = ext_pspacing * (1 - INSET_OVERLAP_TOLERANCE);
// prepare grown lower layer slices for overhang detection
if (this->lower_slices != NULL && this->config->overhangs) {
// We consider overhang any part where the entire nozzle diameter is not supported by the
// lower layer, so we take lower slices and offset them by half the nozzle diameter used
// in the current layer
double nozzle_diameter = this->print_config->nozzle_diameter.get_at(this->config->perimeter_extruder-1);
this->_lower_slices_p = offset(*this->lower_slices, scale_(+nozzle_diameter/2));
}
// we need to process each island separately because we might have different
// extra perimeters for each one
for (Surfaces::const_iterator surface = this->slices->surfaces.begin();
surface != this->slices->surfaces.end(); ++surface) {
// detect how many perimeters must be generated for this island
signed short loop_number = this->config->perimeters + surface->extra_perimeters;
loop_number--; // 0-indexed loops
Polygons gaps;
Polygons last = surface->expolygon.simplify_p(SCALED_RESOLUTION);
if (loop_number >= 0) { // no loops = -1
std::vector<PerimeterGeneratorLoops> contours(loop_number+1); // depth => loops
std::vector<PerimeterGeneratorLoops> holes(loop_number+1); // depth => loops
Polylines thin_walls;
// we loop one time more than needed in order to find gaps after the last perimeter was applied
for (signed short i = 0; i <= loop_number+1; ++i) { // outer loop is 0
Polygons offsets;
if (i == 0) {
// the minimum thickness of a single loop is:
// ext_width/2 + ext_spacing/2 + spacing/2 + width/2
if (this->config->thin_walls) {
offsets = offset2(
last,
-(ext_pwidth/2 + ext_min_spacing/2 - 1),
+(ext_min_spacing/2 - 1)
);
} else {
offsets = offset(last, -ext_pwidth/2);
}
// look for thin walls
if (this->config->thin_walls) {
Polygons diffpp = diff(
last,
offset(offsets, +ext_pwidth/2),
true // medial axis requires non-overlapping geometry
);
// the following offset2 ensures almost nothing in @thin_walls is narrower than $min_width
// (actually, something larger than that still may exist due to mitering or other causes)
coord_t min_width = ext_pwidth / 2;
ExPolygons expp = offset2_ex(diffpp, -min_width/2, +min_width/2);
// the maximum thickness of our thin wall area is equal to the minimum thickness of a single loop
Polylines pp;
for (ExPolygons::const_iterator ex = expp.begin(); ex != expp.end(); ++ex)
ex->medial_axis(ext_pwidth + ext_pspacing2, min_width, &pp);
double threshold = ext_pwidth * 2;
for (Polylines::const_iterator p = pp.begin(); p != pp.end(); ++p) {
if (p->length() > threshold) {
thin_walls.push_back(*p);
}
}
#ifdef DEBUG
printf(" %zu thin walls detected\n", thin_walls.size());
#endif
/*
if (false) {
require "Slic3r/SVG.pm";
Slic3r::SVG::output(
"medial_axis.svg",
no_arrows => 1,
#expolygons => \@expp,
polylines => \@thin_walls,
);
}
*/
}
} else {
coord_t distance = (i == 1) ? ext_pspacing2 : pspacing;
if (this->config->thin_walls) {
offsets = offset2(
last,
-(distance + min_spacing/2 - 1),
+(min_spacing/2 - 1)
);
} else {
offsets = offset(
last,
-distance
);
}
// look for gaps
if (this->config->gap_fill_speed.value > 0 && this->config->fill_density.value > 0) {
// not using safety offset here would "detect" very narrow gaps
// (but still long enough to escape the area threshold) that gap fill
// won't be able to fill but we'd still remove from infill area
ExPolygons diff_expp = diff_ex(
offset(last, -0.5*distance),
offset(offsets, +0.5*distance + 10) // safety offset
);
for (ExPolygons::const_iterator ex = diff_expp.begin(); ex != diff_expp.end(); ++ex) {
if (fabs(ex->area()) >= gap_area_threshold) {
Polygons pp = *ex;
gaps.insert(gaps.end(), pp.begin(), pp.end());
}
}
}
}
if (offsets.empty()) break;
if (i > loop_number) break; // we were only looking for gaps this time
last = offsets;
for (Polygons::const_iterator polygon = offsets.begin(); polygon != offsets.end(); ++polygon) {
PerimeterGeneratorLoop loop(*polygon, i);
loop.is_contour = polygon->is_counter_clockwise();
if (loop.is_contour) {
contours[i].push_back(loop);
} else {
holes[i].push_back(loop);
}
}
}
// nest loops: holes first
for (signed short d = 0; d <= loop_number; ++d) {
PerimeterGeneratorLoops &holes_d = holes[d];
// loop through all holes having depth == d
for (signed short i = 0; i < holes_d.size(); ++i) {
const PerimeterGeneratorLoop &loop = holes_d[i];
// find the hole loop that contains this one, if any
for (signed short t = d+1; t <= loop_number; ++t) {
for (signed short j = 0; j < holes[t].size(); ++j) {
PerimeterGeneratorLoop &candidate_parent = holes[t][j];
if (candidate_parent.polygon.contains(loop.polygon.first_point())) {
candidate_parent.children.push_back(loop);
holes_d.erase(holes_d.begin() + i);
--i;
goto NEXT_LOOP;
}
}
}
// if no hole contains this hole, find the contour loop that contains it
for (signed short t = loop_number; t >= 0; --t) {
for (signed short j = 0; j < contours[t].size(); ++j) {
PerimeterGeneratorLoop &candidate_parent = contours[t][j];
if (candidate_parent.polygon.contains(loop.polygon.first_point())) {
candidate_parent.children.push_back(loop);
holes_d.erase(holes_d.begin() + i);
--i;
goto NEXT_LOOP;
}
}
}
NEXT_LOOP: ;
}
}
// nest contour loops
for (signed short d = loop_number; d >= 1; --d) {
PerimeterGeneratorLoops &contours_d = contours[d];
// loop through all contours having depth == d
for (signed short i = 0; i < contours_d.size(); ++i) {
const PerimeterGeneratorLoop &loop = contours_d[i];
// find the contour loop that contains it
for (signed short t = d-1; t >= 0; --t) {
for (signed short j = 0; j < contours[t].size(); ++j) {
PerimeterGeneratorLoop &candidate_parent = contours[t][j];
if (candidate_parent.polygon.contains(loop.polygon.first_point())) {
candidate_parent.children.push_back(loop);
contours_d.erase(contours_d.begin() + i);
--i;
goto NEXT_CONTOUR;
}
}
}
NEXT_CONTOUR: ;
}
}
// at this point, all loops should be in contours[0]
ExtrusionEntityCollection entities = this->_traverse_loops(contours.front(), thin_walls);
// if brim will be printed, reverse the order of perimeters so that
// we continue inwards after having finished the brim
// TODO: add test for perimeter order
if (this->config->external_perimeters_first
|| (this->layer_id == 0 && this->print_config->brim_width.value > 0))
entities.reverse();
// append perimeters for this slice as a collection
if (!entities.empty())
this->loops->append(entities);
}
// fill gaps
if (!gaps.empty()) {
/*
if (false) {
require "Slic3r/SVG.pm";
Slic3r::SVG::output(
"gaps.svg",
expolygons => union_ex(\@gaps),
);
}
*/
// where $pwidth < thickness < 2*$pspacing, infill with width = 2*$pwidth
// where 0.1*$pwidth < thickness < $pwidth, infill with width = 1*$pwidth
std::vector<PerimeterGeneratorGapSize> gap_sizes;
gap_sizes.push_back(PerimeterGeneratorGapSize(pwidth, 2*pspacing, 2*pwidth));
gap_sizes.push_back(PerimeterGeneratorGapSize(0.1*pwidth, pwidth, 1*pwidth));
for (std::vector<PerimeterGeneratorGapSize>::const_iterator gap_size = gap_sizes.begin();
gap_size != gap_sizes.end(); ++gap_size) {
ExtrusionEntityCollection gap_fill = this->_fill_gaps(gap_size->min,
gap_size->max, unscale(gap_size->width), gaps);
this->gap_fill->append(gap_fill.entities);
// Make sure we don't infill narrow parts that are already gap-filled
// (we only consider this surface's gaps to reduce the diff() complexity).
// Growing actual extrusions ensures that gaps not filled by medial axis
// are not subtracted from fill surfaces (they might be too short gaps
// that medial axis skips but infill might join with other infill regions
// and use zigzag).
coord_t dist = gap_size->width/2;
Polygons filled;
for (ExtrusionEntitiesPtr::const_iterator it = gap_fill.entities.begin();
it != gap_fill.entities.end(); ++it) {
Polygons f;
offset((*it)->as_polyline(), &f, dist);
filled.insert(filled.end(), f.begin(), f.end());
}
last = diff(last, filled);
gaps = diff(gaps, filled); // prevent more gap fill here
}
}
// create one more offset to be used as boundary for fill
// we offset by half the perimeter spacing (to get to the actual infill boundary)
// and then we offset back and forth by half the infill spacing to only consider the
// non-collapsing regions
coord_t inset = 0;
if (loop_number == 0) {
// one loop
inset += ext_pspacing2/2;
} else if (loop_number > 0) {
// two or more loops
inset += pspacing/2;
}
// only apply infill overlap if we actually have one perimeter
if (inset > 0)
inset -= this->config->get_abs_value("infill_overlap", inset + ispacing/2);
{
ExPolygons expp = union_ex(last);
// simplify infill contours according to resolution
Polygons pp;
for (ExPolygons::const_iterator ex = expp.begin(); ex != expp.end(); ++ex)
ex->simplify_p(SCALED_RESOLUTION, &pp);
// collapse too narrow infill areas
coord_t min_perimeter_infill_spacing = ispacing * (1 - INSET_OVERLAP_TOLERANCE);
expp = offset2_ex(
pp,
-inset -min_perimeter_infill_spacing/2,
+min_perimeter_infill_spacing/2
);
// append infill areas to fill_surfaces
for (ExPolygons::const_iterator ex = expp.begin(); ex != expp.end(); ++ex)
this->fill_surfaces->surfaces.push_back(Surface(stInternal, *ex)); // use a bogus surface type
}
}
}
//---------------------------------------------------------------------
void PlayPen_testPoseAnimationWithoutNormals::setupContent()
{
mSceneMgr->setAmbientLight(ColourValue(0.5, 0.5, 0.5));
Vector3 dir(-1, -1, 0.5);
dir.normalise();
Light* l = mSceneMgr->createLight("light1");
l->setType(Light::LT_DIRECTIONAL);
l->setDirection(dir);
MeshPtr mesh = MeshManager::getSingleton().load("cube.mesh",
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
String newName = "testposenonormals.mesh";
mesh = mesh->clone(newName);
SubMesh* sm = mesh->getSubMesh(0);
// Re-organise geometry since this mesh has no animation and all
// vertex elements are packed into one buffer
VertexDeclaration* newDecl =
sm->vertexData->vertexDeclaration->getAutoOrganisedDeclaration(false, true, false);
sm->vertexData->reorganiseBuffers(newDecl);
// create 2 poses
Pose* pose = mesh->createPose(1, "pose1");
// Pose1 moves vertices 0, 1, 2 and 3 upward
Vector3 offset1(0, 50, 0);
pose->addVertex(0, offset1);
pose->addVertex(1, offset1);
pose->addVertex(2, offset1);
pose->addVertex(3, offset1);
pose = mesh->createPose(1, "pose2");
// Pose2 moves vertices 3, 4, and 5 to the right
// Note 3 gets affected by both
Vector3 offset2(100, 0, 0);
pose->addVertex(3, offset2);
pose->addVertex(4, offset2);
pose->addVertex(5, offset2);
Animation* anim = mesh->createAnimation("poseanim", 20.0f);
VertexAnimationTrack* vt = anim->createVertexTrack(1, sm->vertexData, VAT_POSE);
// Frame 0 - no effect
VertexPoseKeyFrame* kf = vt->createVertexPoseKeyFrame(0);
// Frame 1 - bring in pose 1 (index 0)
kf = vt->createVertexPoseKeyFrame(3);
kf->addPoseReference(0, 1.0f);
// Frame 2 - remove all
kf = vt->createVertexPoseKeyFrame(6);
// Frame 3 - bring in pose 2 (index 1)
kf = vt->createVertexPoseKeyFrame(9);
kf->addPoseReference(1, 1.0f);
// Frame 4 - remove all
kf = vt->createVertexPoseKeyFrame(12);
// Frame 5 - bring in pose 1 at 50%, pose 2 at 100%
kf = vt->createVertexPoseKeyFrame(15);
kf->addPoseReference(0, 0.5f);
kf->addPoseReference(1, 1.0f);
// Frame 6 - bring in pose 1 at 100%, pose 2 at 50%
kf = vt->createVertexPoseKeyFrame(18);
kf->addPoseReference(0, 1.0f);
kf->addPoseReference(1, 0.5f);
// Frame 7 - reset
kf = vt->createVertexPoseKeyFrame(20);
// Export the mesh
DataStreamPtr stream = Root::getSingleton().createFileStream(newName, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, true);
MeshSerializer ser;
ser.exportMesh(mesh.get(), stream);
stream->close();
// Unload old mesh to force reload
MeshManager::getSingleton().remove(mesh->getHandle());
mesh->unload();
mesh.setNull();
Entity* e;
AnimationState* animState;
// software pose
e = mSceneMgr->createEntity("test2", newName);
mSceneMgr->getRootSceneNode()->createChildSceneNode(Vector3(150,0,0))->attachObject(e);
animState = e->getAnimationState("poseanim");
animState->setEnabled(true);
animState->setWeight(1.0f);
mAnimStateList.push_back(animState);
// test hardware pose
e = mSceneMgr->createEntity("test", newName);
mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(e);
e->setMaterialName("Examples/HardwarePoseAnimation");
animState = e->getAnimationState("poseanim");
animState->setEnabled(true);
animState->setWeight(1.0f);
mAnimStateList.push_back(animState);
mCamera->setNearClipDistance(0.5);
Plane plane;
plane.normal = Vector3::UNIT_Y;
plane.d = 200;
MeshManager::getSingleton().createPlane("Myplane",
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, plane,
1500,1500,10,10,true,1,5,5,Vector3::UNIT_Z);
Entity* pPlaneEnt = mSceneMgr->createEntity( "plane", "Myplane" );
pPlaneEnt->setMaterialName("2 - Default");
pPlaneEnt->setCastShadows(false);
mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(pPlaneEnt);
mCamera->setPosition(0,-200,-300);
mCamera->lookAt(0,0,0);
}
// Draw curve.
void qxgeditScale::paintEvent ( QPaintEvent *pPaintEvent )
{
QPainter painter(this);
const int h = height();
const int w = width();
const int h2 = h >> 1;
const int x1 = 6 + int((m_iBreak1 * (w - 12)) >> 7);
const int x2 = 6 + int((m_iBreak2 * (w - 12)) >> 7);
const int x3 = 6 + int((m_iBreak3 * (w - 12)) >> 7);
const int x4 = 6 + int((m_iBreak4 * (w - 12)) >> 7);
const int y1 = h2 - ((int(m_iOffset1) - 64) * (h - 12) >> 7);
const int y2 = h2 - ((int(m_iOffset2) - 64) * (h - 12) >> 7);
const int y3 = h2 - ((int(m_iOffset3) - 64) * (h - 12) >> 7);
const int y4 = h2 - ((int(m_iOffset4) - 64) * (h - 12) >> 7);
m_poly.putPoints(0, 6,
0, y1,
x1, y1,
x2, y2,
x3, y3,
x4, y4,
w, y4);
const QPalette& pal = palette();
const bool bDark = (pal.window().color().value() < 0x7f);
const QColor& rgbLite = (bDark ? Qt::darkYellow : Qt::yellow);
if (bDark)
painter.fillRect(0, 0, w, h, pal.dark().color());
painter.setRenderHint(QPainter::Antialiasing, true);
painter.setPen(bDark ? Qt::gray : Qt::darkGray);
const QPen oldpen(painter.pen());
QPen dotpen(oldpen);
dotpen.setStyle(Qt::DotLine);
painter.setPen(dotpen);
painter.drawLine(0, h2, w, h2);
painter.setPen(oldpen);
painter.drawPolyline(m_poly);
painter.setBrush(rgbLite); // pal.midlight().color()
painter.drawRect(nodeRect(1));
painter.drawRect(nodeRect(2));
painter.drawRect(nodeRect(3));
painter.drawRect(nodeRect(4));
#ifdef CONFIG_DEBUG_0
painter.drawText(QFrame::rect(),
Qt::AlignTop|Qt::AlignHCenter,
tr("Break (%1,%2,%3,%4) Offset(%5,%6,%7,%8)")
.arg(int(break1()))
.arg(int(break2()))
.arg(int(break3()))
.arg(int(break4()))
.arg(int(offset1()) - 64)
.arg(int(offset2()) - 64)
.arg(int(offset3()) - 64)
.arg(int(offset4()) - 64));
#endif
painter.setRenderHint(QPainter::Antialiasing, false);
painter.end();
QFrame::paintEvent(pPaintEvent);
}
void BigPuppy::setup(tgWorld& world)
{
//Rod and Muscle configuration. Todo: make these into structs in a namespace block!
const double density = 4.2/300.0; //Note: this needs to be high enough or things fly apart...
const double radius = 0.5;
const double rod_space = 10.0;
const double friction = 0.5;
const double rollFriction = 0.0;
const double restitution = 0.0;
const tgRod::Config rodConfig(radius, density, friction, rollFriction, restitution);
const double radius2 = 0.15;
const double density2 = 1; // Note: This needs to be high enough or things fly apart...
const tgRod::Config rodConfig2(radius2, density2);
const double stiffness = 1000.0;
const double damping = .01*stiffness;
const double pretension = 0.0;
const bool history = false;
const double maxTens = 7000.0;
const double maxSpeed = 12.0;
const double passivePretension = 700; // 5 N
#ifdef USE_KINEMATIC
const double mRad = 1.0;
const double motorFriction = 10.0;
const double motorInertia = 1.0;
const bool backDrivable = false;
tgKinematicActuator::Config motorConfig(2000, 20, passivePretension,
mRad, motorFriction, motorInertia, backDrivable,
history, maxTens, maxSpeed);
#else
const tgSpringCableActuator::Config stringConfig(stiffness, damping, pretension, false, 7000, 24);
tgSpringCableActuator::Config muscleConfig(2000, 20, passivePretension);
#endif
// Calculations for the flemons spine model
double v_size = 10.0;
//Todo: make separate functions for node, rod, and muscle placement! Do for each type of segment.
//Foot:
tgStructure foot;
//Foot nodes. Todo: make into separate function
foot.addNode(8,0,8);//0
foot.addNode(8,0,-8);//1
foot.addNode(-8,0,-8);//2
foot.addNode(-8,0,8);//3
foot.addNode(4,rod_space/2,0);//4
foot.addNode(0,rod_space/2,-4);//5
foot.addNode(-4,rod_space/2,0);//6
foot.addNode(0,rod_space/2,4);//7
//Foot rods. Todo: make into separate function
foot.addPair(0,6,"rod");
foot.addPair(1,7,"rod");
foot.addPair(2,4,"rod");
foot.addPair(3,5,"rod");
//Create basic unit for right leg. Todo: make just one basic unit for right and left legs, since they're now the same.
tgStructure rightLeg;
//Right Leg nodes:
rightLeg.addNode(0,0,0); //0: Bottom Center of lower leg segment
rightLeg.addNode(0,10,0); //1: Center of lower leg segment
rightLeg.addNode(10,10,0); //2: Right of lower leg segment
rightLeg.addNode(-10,10,0); //3: Left of lower leg segment
rightLeg.addNode(0,20,0); //4: Top of lower leg segment
rightLeg.addNode(0,-4,0); //5: was z=3; was y=-3
//rightLeg.addNode(0,-3,-3); //6
//rightLeg.addNode(3,-3,0); //7
//rightLeg.addNode(-3,-3,0); //8
//Add rods for right leg:
rightLeg.addPair(0,1,"rod");
rightLeg.addPair(1,2,"rod");
rightLeg.addPair(1,3,"rod");
rightLeg.addPair(1,4,"rod");
rightLeg.addPair(0,5,"rod");
//rightLeg.addPair(0,6,"rod");
//rightLeg.addPair(0,7,"rod");
//rightLeg.addPair(0,8,"rod");
//Create basic unit for left leg
tgStructure leftLeg;
//Left Leg nodes:
leftLeg.addNode(0,0,0); //0: Bottom Center of lower leg segment
leftLeg.addNode(0,10,0); //1: Center of lower leg segment
leftLeg.addNode(10,10,0); //2: Right of lower leg segment
leftLeg.addNode(-10,10,0); //3: Left of lower leg segment
leftLeg.addNode(0,20,0); //4: Top of lower leg segment
leftLeg.addNode(0,-4,0); //5: was z=3; was y=-3
//leftLeg.addNode(0,-3,-3); //6
//leftLeg.addNode(3,-3,0); //7
//leftLeg.addNode(-3,-3,0); //8
//Add rods for left leg:
leftLeg.addPair(0,1,"rod");
leftLeg.addPair(1,2,"rod");
leftLeg.addPair(1,3,"rod");
leftLeg.addPair(1,4,"rod");
leftLeg.addPair(0,5,"rod");
//leftLeg.addPair(0,6,"rod");
//leftLeg.addPair(0,7,"rod");
//leftLeg.addPair(0,8,"rod");
//Create the basic unit of the spine
tgStructure tetra;
//Add the nodes
tetra.addNode(0,0,0); //Node 0
tetra.addNode(v_size, 0, v_size); //Node 1
tetra.addNode(v_size, 0, -v_size); //Node 2
tetra.addNode(-v_size, 0, -v_size); //Node 3
tetra.addNode(-v_size, 0, v_size); //Node 4
tetra.addPair(0,1,"rod");
tetra.addPair(0,2,"rod");
tetra.addPair(0,3,"rod");
tetra.addPair(0,4,"rod");
//Create the basic unit for the hips/shoulders:
tgStructure lHip;
lHip.addNode(0,0,0); //Node 0
lHip.addNode(0, v_size, v_size); //Node 1
lHip.addNode(0, -v_size, -v_size); //Node 2
lHip.addNode(0, -v_size, v_size); //Node 3
lHip.addPair(0,1,"rod");
lHip.addPair(0,2,"rod");
lHip.addPair(0,3,"rod");
tgStructure rHip;
rHip.addNode(0,0,0); //Node 0
rHip.addNode(0, v_size, -v_size); //Node 1
rHip.addNode(0, -v_size, -v_size); //Node 2
rHip.addNode(0, -v_size, v_size); //Node 3
rHip.addPair(0,1,"rod");
rHip.addPair(0,2,"rod");
rHip.addPair(0,3,"rod");
//Build the spine
tgStructure spine;
const double offsetDist = v_size + 1; //So rod ends don't touch, may need to adjust
const double offsetDist2 = v_size*5 + 5 + 3.3;
const double offsetDist3 = v_size*6;
const double yOffset_leg = -21.0;
const double yOffset_foot = -26.0;
std::size_t m_segments = 6;
std::size_t m_hips = 4;
std::size_t m_legs = 4;
std::size_t m_feet = 4;
//Vertebrae
btVector3 offset(offsetDist,0.0,0);
//Hips
btVector3 offset1(offsetDist*2,0.0,offsetDist);
btVector3 offset2(offsetDist2,0.0,offsetDist);
btVector3 offset3(offsetDist*2,0.0,-offsetDist);
btVector3 offset4(offsetDist2,0.0,-offsetDist);
//Lower legs
btVector3 offset5(offsetDist3,yOffset_leg,offsetDist);
btVector3 offset6(offsetDist3,yOffset_leg,-offsetDist);
btVector3 offset7(v_size*2,yOffset_leg,offsetDist);
btVector3 offset8(v_size*2,yOffset_leg,-offsetDist);
//Feet
btVector3 offset9(offsetDist3+1,yOffset_foot,offsetDist);
btVector3 offset10(offsetDist3+1,yOffset_foot,-offsetDist);
btVector3 offset11(v_size*2+1,yOffset_foot,offsetDist);
btVector3 offset12(v_size*2+1,yOffset_foot,-offsetDist);
for(std::size_t i = 0; i < m_segments; i++) { //Connect segments for spine
tgStructure* t = new tgStructure (tetra);
t->addTags(tgString("segment num", i + 1));
t->move((i + 1)*offset);
if (i % 2 == 1) {
t->addRotation(btVector3((i + 1) * offsetDist, 0.0, 0.0), btVector3(1, 0, 0), 0.0);
}
else {
t->addRotation(btVector3((i + 1) * offsetDist, 0.0, 0.0), btVector3(1, 0, 0), M_PI/2.0);
}
spine.addChild(t); //Add a segment to the spine
}
for(std::size_t i = m_segments; i < (m_segments + 2); i++) {//deal with right hip and shoulder first
tgStructure* t = new tgStructure (rHip);
t->addTags(tgString("segment num", i + 1));
if(i % 2 == 0) {
t->move(offset1);
t->addRotation(btVector3(offsetDist*2, 0.0, offsetDist), btVector3(1, 0, 0), 0.0);
}
else {
t->move(offset2);
t->addRotation(btVector3(offsetDist2, 0.0, offsetDist), btVector3(0, 0, 1), M_PI*1/8);
}
spine.addChild(t); //Add a segment to the spine
}
for(std::size_t i = (m_segments + 2); i < (m_segments + m_hips); i++) {//deal with left hip and shoulder now
tgStructure* t = new tgStructure (lHip);
t->addTags(tgString("segment num", i + 1));
if(i % 2 == 0) {
t->move(offset3);
t->addRotation(btVector3(offsetDist*2, 0.0, -offsetDist), btVector3(1, 0, 0), 0.0);
}
else {
t->move(offset4);
t->addRotation(btVector3(offsetDist2, 0.0, -offsetDist), btVector3(0, 0, 1), M_PI*1/8);
}
spine.addChild(t); //Add a segment to the spine
}
for(std::size_t i = (m_segments + m_hips); i < (m_segments + m_hips + 2); i++) {//right front and back legs
tgStructure* t = new tgStructure (rightLeg);
t->addTags(tgString("segment num", i + 1));
if(i % 2 == 0) {
t->move(offset7);
t->addRotation(btVector3(v_size*2, yOffset_leg, offsetDist), btVector3(0, 1, 0), M_PI);
}
else {
t->move(offset5);
t->addRotation(btVector3(offsetDist3, yOffset_leg, offsetDist), btVector3(0, 1, 0), M_PI);
}
spine.addChild(t); //Add a segment to the spine
}
for(std::size_t i = (m_segments + m_hips + 2); i < (m_segments + m_hips + m_legs); i++) {//left front and back legs
tgStructure* t = new tgStructure (leftLeg);
t->addTags(tgString("segment num", i + 1));
if(i % 2 == 0) {
t->move(offset8);
t->addRotation(btVector3(v_size*2, yOffset_leg, -offsetDist), btVector3(0, 1, 0), M_PI);
}
else {
t->move(offset6);
t->addRotation(btVector3(offsetDist3, yOffset_leg, -offsetDist), btVector3(0, 1, 0), M_PI);
}
spine.addChild(t); //Add a segment to the spine
}
for(std::size_t i = (m_segments + m_hips + m_legs); i < (m_segments + m_hips + m_legs + 2); i++) {//right front and back feet
tgStructure* t = new tgStructure (foot);
t->addTags(tgString("segment num", i + 1));
if(i % 2 == 0) {
t->move(offset11);
t->addRotation(btVector3(v_size*2+1, yOffset_foot, offsetDist), btVector3(0, 1, 0), 0.0);
}
else {
t->move(offset9);
t->addRotation(btVector3(offsetDist3+1, yOffset_foot, offsetDist), btVector3(0, 1, 0), 0.0);
}
spine.addChild(t); //Add a segment to the spine
}
for(std::size_t i = (m_segments + m_hips + m_legs + 2); i < (m_segments + m_hips + m_legs + m_feet); i++) {//left front and back feet
tgStructure* t = new tgStructure (foot);
t->addTags(tgString("segment num", i + 1));
if(i % 2 == 0) {
t->move(offset12);
t->addRotation(btVector3(v_size*2+1, yOffset_foot, -offsetDist), btVector3(0, 1, 0), 0.0);
}
else {
t->move(offset10);
t->addRotation(btVector3(offsetDist3+1, yOffset_foot, -offsetDist), btVector3(0, 1, 0), 0.0);
}
spine.addChild(t); //Add a segment to the spine
}
#ifdef SMALL_HILLS
spine.move(btVector3(0.0,-yOffset_foot+5,0.0));
#endif
#ifdef LARGE_HILLS
spine.move(btVector3(0.0,-yOffset_foot+12,0.0));
#endif
#ifdef FLAT_GROUND
spine.move(btVector3(0.0,-yOffset_foot,0.0));
#endif
#ifdef BLOCKY_GROUND
spine.move(btVector3(0.0,10.0,0.0));
#endif
#ifdef STAIRS
spine.move(btVector3(0.0,0.0,0.0));
#endif
std::vector<tgStructure*> children = spine.getChildren();
for(std::size_t i = 2; i < (children.size() - (m_hips + m_legs + m_feet)); i++) {
tgNodes n0 = children[i-2]->getNodes();
tgNodes n1 = children[i-1]->getNodes();
tgNodes n2 = children[i]->getNodes();
if(i==2) {
//Extra muscles, to keep front vertebra from swinging.
spine.addPair(n0[3], n1[3], tgString("spine front upper right muscle seg", i-2) + tgString(" seg", i-1));
spine.addPair(n0[3], n1[4], tgString("spine front upper left muscle seg", i-2) + tgString(" seg", i-1));
}
//Add muscles to the spine
if(i < 3) {
if(i % 2 == 0) { //front
spine.addPair(n0[1], n1[3], tgString("spine front lower right muscle seg", i-2) + tgString(" seg", i-1));
spine.addPair(n0[1], n1[4], tgString("spine front lower left muscle seg", i-2) + tgString(" seg", i-1));
spine.addPair(n0[2], n1[3], tgString("spine front upper right muscle seg", i-2) + tgString(" seg", i-1));
spine.addPair(n0[2], n1[4], tgString("spine front upper left muscle seg", i-2) + tgString(" seg", i-1));
}
else { //rear
spine.addPair(n0[1], n1[3], tgString("spine rear upper left muscle seg", i-2) + tgString(" seg", i-1));
spine.addPair(n0[1], n1[4], tgString("spine rear lower left muscle seg", i-2) + tgString(" seg", i-1));
spine.addPair(n0[2], n1[3], tgString("spine rear upper right muscle seg", i-2) + tgString(" seg", i-1));
spine.addPair(n0[2], n1[4], tgString("spine rear lower right muscle seg", i-2) + tgString(" seg", i-1));
}
}
if(i < 6) {
if(i % 2 == 0) {
spine.addPair(n0[1], n2[4], tgString("spine bottom muscle seg", i-2) + tgString(" seg", i-1));
spine.addPair(n0[2], n2[3], tgString("spine top muscle seg", i-2) + tgString(" seg", i-1));
}
else {
spine.addPair(n0[1], n2[4], tgString("spine lateral left muscle seg", i-2) + tgString(" seg", i-1));
spine.addPair(n0[2], n2[3], tgString("spine lateral right muscle seg", i-2) + tgString(" seg", i-1));
}
}
if(i > 0 && i < 5) {
if(i % 2 == 0) { //rear
spine.addPair(n1[1], n2[3], tgString("spine rear upper left muscle seg", i-1) + tgString(" seg", i));
spine.addPair(n1[1], n2[4], tgString("spine rear lower left muscle seg", i-1) + tgString(" seg", i));
spine.addPair(n1[2], n2[3], tgString("spine rear upper right muscle seg", i-1) + tgString(" seg", i));
spine.addPair(n1[2], n2[4], tgString("spine rear lower right muscle seg", i-1) + tgString(" seg", i));
}
else { //front
spine.addPair(n1[1], n2[3], tgString("spine front lower right muscle seg", i-1) + tgString(" seg", i));
spine.addPair(n1[1], n2[4], tgString("spine front lower left muscle seg", i-1) + tgString(" seg", i));
spine.addPair(n1[2], n2[3], tgString("spine front upper right muscle seg", i-1) + tgString(" seg", i));
spine.addPair(n1[2], n2[4], tgString("spine front upper left muscle seg", i-1) + tgString(" seg", i));
}
}
if(i == 5) {
//rear
spine.addPair(n1[1], n2[1], tgString("spine rear lower left muscle seg", i-1) + tgString(" seg", i));
spine.addPair(n1[1], n2[2], tgString("spine rear lower right muscle seg", i-1) + tgString(" seg", i));
spine.addPair(n1[2], n2[1], tgString("spine rear upper left muscle seg", i-1) + tgString(" seg", i));
spine.addPair(n1[2], n2[2], tgString("spine rear upper right muscle seg", i-1) + tgString(" seg", i));
//front
spine.addPair(n1[1], n2[3], tgString("spine front lower right muscle seg", i-1) + tgString(" seg", i));
spine.addPair(n1[1], n2[4], tgString("spine front lower left muscle seg", i-1) + tgString(" seg", i));
spine.addPair(n1[2], n2[3], tgString("spine front upper right muscle seg", i-1) + tgString(" seg", i));
spine.addPair(n1[2], n2[4], tgString("spine front upper left muscle seg", i-1) + tgString(" seg", i));
}
}
//Now add muscles to hips....
tgNodes n0 = children[0]->getNodes();
tgNodes n1 = children[1]->getNodes();
tgNodes n2 = children[2]->getNodes();
tgNodes n3 = children[3]->getNodes();
tgNodes n4 = children[4]->getNodes();
tgNodes n5 = children[5]->getNodes();
tgNodes n6 = children[6]->getNodes();
tgNodes n7 = children[7]->getNodes();
tgNodes n8 = children[8]->getNodes();
tgNodes n9 = children[9]->getNodes();
tgNodes n10 = children[10]->getNodes();
tgNodes n11 = children[11]->getNodes();
tgNodes n12 = children[12]->getNodes();
tgNodes n13 = children[13]->getNodes();
//Left shoulder muscles
spine.addPair(n6[1], n1[1], tgString("left shoulder rear upper muscle seg", 6) + tgString(" seg", 1));
spine.addPair(n6[1], n1[4], tgString("left shoulder front upper muscle seg", 6) + tgString(" seg", 1));
spine.addPair(n6[1], n0[2], tgString("left shoulder front top muscle seg", 6) + tgString(" seg", 0));
spine.addPair(n6[1], n2[3], tgString("left shoulder rear top muscle seg", 6) + tgString(" seg", 2));
spine.addPair(n6[2], n1[1], tgString("left shoulder rear lower muscle seg", 6) + tgString(" seg", 1));
spine.addPair(n6[2], n1[4], tgString("left shoulder front lower muscle seg", 6) + tgString(" seg", 1));
spine.addPair(n6[2], n0[1], tgString("left shoulder front bottom muscle seg", 6) + tgString(" seg", 0));
spine.addPair(n6[2], n2[4], tgString("left shoulder rear bottom muscle seg", 6) + tgString(" seg", 2));
//Extra muscles, to move left shoulder forward and back:
spine.addPair(n6[0], n1[1], tgString("left shoulder rear mid muscle seg", 6) + tgString(" seg", 1));
spine.addPair(n6[0], n1[4], tgString("left shoulder front mid muscle seg", 6) + tgString(" seg", 1));
//Left hip muscles
spine.addPair(n7[1], n5[1], tgString("left hip rear upper muscle seg", 7) + tgString(" seg", 5));
spine.addPair(n7[1], n5[4], tgString("left hip front upper muscle seg", 7) + tgString(" seg", 5));
spine.addPair(n7[1], n4[2], tgString("left hip rear top muscle seg", 7) + tgString(" seg", 4));
spine.addPair(n7[1], n4[3], tgString("left hip front top muscle seg", 7) + tgString(" seg", 4));
spine.addPair(n7[2], n5[1], tgString("left hip rear lower muscle seg", 7) + tgString(" seg", 5));
spine.addPair(n7[2], n5[4], tgString("left hip front lower muscle seg", 7) + tgString(" seg", 5));
spine.addPair(n7[2], n4[1], tgString("left hip bottom muscle seg", 7) + tgString(" seg", 4));
//Extra muscles, to move left hip forward and back:
spine.addPair(n7[0], n3[1], tgString("left hip rear mid muscle seg", 7) + tgString(" seg", 3)); //could also be n3[3]
spine.addPair(n7[0], n5[4], tgString("left hip front mid muscle seg", 7) + tgString(" seg", 5));
//Inter-hip connector muscle
spine.addPair(n7[2], n9[3], tgString("inter-hip bottom muscle seg", 7) + tgString(" seg", 9)); //inter-hip bottom muscle
//Right shoulder muscles
spine.addPair(n8[1], n1[2], tgString("right shoulder rear upper muscle seg", 8) + tgString(" seg", 1));
spine.addPair(n8[1], n1[3], tgString("right shoulder front upper muscle seg", 8) + tgString(" seg", 1));
spine.addPair(n8[1], n0[2], tgString("right shoulder front top muscle seg", 8) + tgString(" seg", 0));
spine.addPair(n8[1], n2[3], tgString("right shoulder rear top muscle seg", 8) + tgString(" seg", 2));
spine.addPair(n8[3], n1[2], tgString("right shoulder rear lower muscle seg", 8) + tgString(" seg", 1));
spine.addPair(n8[3], n1[3], tgString("right shoulder front lower muscle seg", 8) + tgString(" seg", 1));
spine.addPair(n8[3], n0[1], tgString("right shoulder front bottom muscle seg", 8) + tgString(" seg", 0));
spine.addPair(n8[3], n2[4], tgString("right shoulder rear bottom muscle seg", 8) + tgString(" seg", 2));
//Extra muscles, to move right shoulder forward and back:
spine.addPair(n8[0], n1[2], tgString("right shoulder rear mid muscle seg", 8) + tgString(" seg", 1));
spine.addPair(n8[0], n1[3], tgString("right shoulder front mid muscle seg", 8) + tgString(" seg", 1));
//Right hip muscles
spine.addPair(n9[1], n5[2], tgString("right hip rear upper muscle seg", 9) + tgString(" seg", 5));
spine.addPair(n9[1], n5[3], tgString("right hip front upper muscle seg", 9) + tgString(" seg", 5));
spine.addPair(n9[1], n4[2], tgString("right hip rear top muscle seg", 9) + tgString(" seg", 4));
spine.addPair(n9[1], n4[3], tgString("right hip front top muscle seg", 9) + tgString(" seg", 4));
spine.addPair(n9[3], n5[2], tgString("right hip rear lower muscle seg", 9) + tgString(" seg", 5));
spine.addPair(n9[3], n5[3], tgString("right hip front lower muscle seg", 9) + tgString(" seg", 5));
spine.addPair(n9[3], n4[1], tgString("right hip bottom muscle seg", 9) + tgString(" seg", 4));
//Extra muscles, to move right hip forward and back:
spine.addPair(n9[0], n3[2], tgString("right hip rear mid muscle seg", 9) + tgString(" seg", 3)); //could also be n3[3]
spine.addPair(n9[0], n5[3], tgString("right hip front mid muscle seg", 9) + tgString(" seg", 5));
//Leg/hip connections:
//Right front leg/shoulder
spine.addPair(n10[4], n6[2], tgString("right outer bicep muscle seg", 10) + tgString(" seg", 6));
spine.addPair(n10[4], n6[3], tgString("right inner bicep muscle seg", 10) + tgString(" seg", 6));
spine.addPair(n10[4], n1[4], tgString("right front abdomen connection muscle seg", 10) + tgString(" seg", 1));
spine.addPair(n10[3], n6[2], tgString("right outer tricep muscle seg", 10) + tgString(" seg", 6));
spine.addPair(n10[3], n6[3], tgString("right inner tricep muscle seg", 10) + tgString(" seg", 6));
spine.addPair(n10[2], n6[2], tgString("right outer front tricep muscle seg", 10) + tgString(" seg", 6));
spine.addPair(n10[2], n6[3], tgString("right inner front tricep muscle seg", 10) + tgString(" seg", 6));
//Adding muscle to pull up on right front leg:
spine.addPair(n10[4], n6[1], tgString("right mid bicep muscle seg", 10) + tgString(" seg", 6));
//Left front leg/shoulder
spine.addPair(n12[4], n8[2], tgString("left inner bicep muscle seg", 12) + tgString(" seg", 8));
spine.addPair(n12[4], n8[3], tgString("left outer bicep muscle seg", 12) + tgString(" seg", 8));
spine.addPair(n12[4], n1[3], tgString("left front abdomen connection muscle seg", 12) + tgString(" seg", 1)); //Was n1[2]
spine.addPair(n12[3], n8[2], tgString("left inner tricep muscle seg", 12) + tgString(" seg", 8));
spine.addPair(n12[3], n8[3], tgString("left outer tricep muscle seg", 12) + tgString(" seg", 8));
spine.addPair(n12[2], n8[2], tgString("left inner front tricep muscle seg", 12) + tgString(" seg", 8));
spine.addPair(n12[2], n8[3], tgString("left outer front tricep muscle seg", 12) + tgString(" seg", 8));
//Adding muscle to pull up on left front leg:
spine.addPair(n12[4], n8[1], tgString("left mid bicep muscle seg", 12) + tgString(" seg", 8));
//Right rear leg/hip
spine.addPair(n11[4], n7[2], tgString("right outer thigh muscle seg", 11) + tgString(" seg", 7));
spine.addPair(n11[4], n7[3], tgString("right inner thigh muscle seg", 11) + tgString(" seg", 7));
spine.addPair(n11[4], n3[4],tgString("right rear abdomen connection muscle seg", 11) + tgString(" seg", 3));
spine.addPair(n11[3], n5[1],tgString("right rear abdomen connection muscle seg", 11) + tgString(" seg", 5));
spine.addPair(n11[3], n7[2], tgString("right outer calf muscle seg", 11) + tgString(" seg", 7));
spine.addPair(n11[3], n7[3], tgString("right inner calf muscle seg", 11) + tgString(" seg", 7));
spine.addPair(n11[2], n7[2], tgString("right outer front calf muscle seg", 11) + tgString(" seg", 7));
spine.addPair(n11[2], n7[3], tgString("right inner front calf muscle seg", 11) + tgString(" seg", 7));
//Adding muscle to pull rear right leg up:
spine.addPair(n11[4], n7[1], tgString("right central thigh muscle seg", 11) + tgString(" seg", 7));
//Left rear leg/hip
spine.addPair(n13[4], n9[2], tgString("left inner thigh muscle seg", 13) + tgString(" seg", 9));
spine.addPair(n13[4], n9[3], tgString("left outer thigh muscle seg", 13) + tgString(" seg", 9));
spine.addPair(n13[4], n3[3], tgString("left rear abdomen connection muscle seg", 13) + tgString(" seg", 3));
spine.addPair(n13[3], n5[2], tgString("left rear abdomen connection muscle seg", 13) + tgString(" seg", 5));
spine.addPair(n13[3], n9[2], tgString("left inner calf muscle seg", 13) + tgString(" seg", 9));
spine.addPair(n13[3], n9[3], tgString("left outer calf muscle seg", 13) + tgString(" seg", 9));
spine.addPair(n13[2], n9[2], tgString("left inner front calf muscle seg", 13) + tgString(" seg", 9));
spine.addPair(n13[2], n9[3], tgString("left outer front calf muscle seg", 13) + tgString(" seg", 9));
//Adding muscle to pull rear left leg up:
spine.addPair(n13[4], n9[1], tgString("left central thigh muscle seg", 13) + tgString(" seg", 9));
//Populate feet with muscles. Todo: think up names to differentiate each!
for(std::size_t i = (m_segments + m_hips + m_legs); i < children.size(); i++) {
tgNodes ni = children[i]->getNodes();
tgNodes ni4 = children[i-4]->getNodes(); //Think of a nicer name for this!
spine.addPair(ni[0],ni[1],tgString("foot muscle seg", i));
spine.addPair(ni[0],ni[3],tgString("foot muscle seg", i));
spine.addPair(ni[1],ni[2],tgString("foot muscle seg", i));
spine.addPair(ni[2],ni[3],tgString("foot muscle seg", i));
spine.addPair(ni[0],ni[7],tgString("foot muscle seg", i));
spine.addPair(ni[1],ni[4],tgString("foot muscle seg", i));
spine.addPair(ni[2],ni[5],tgString("foot muscle seg", i));
spine.addPair(ni[3],ni[6],tgString("foot muscle seg", i));
spine.addPair(ni[4],ni[5],tgString("foot muscle seg", i));
spine.addPair(ni[4],ni[7],tgString("foot muscle seg", i));
spine.addPair(ni[5],ni[6],tgString("foot muscle seg", i));
spine.addPair(ni[6],ni[7],tgString("foot muscle seg", i));
//Connecting feet to legs:
//spine.addPair(ni4[5],ni[1],tgString("foot muscle seg", i) + tgString(" seg", i-4));
//spine.addPair(ni4[5],ni[2],tgString("foot muscle seg", i) + tgString(" seg", i-4));
//spine.addPair(ni4[5],ni[5],tgString("foot muscle seg", i) + tgString(" seg", i-4));
//spine.addPair(ni4[6],ni[0],tgString("foot muscle seg", i) + tgString(" seg", i-4));
//spine.addPair(ni4[6],ni[3],tgString("foot muscle seg", i) + tgString(" seg", i-4));
//spine.addPair(ni4[6],ni[7],tgString("foot muscle seg", i) + tgString(" seg", i-4));
//spine.addPair(ni4[7],ni[0],tgString("foot muscle seg", i) + tgString(" seg", i-4));
//spine.addPair(ni4[7],ni[1],tgString("foot muscle seg", i) + tgString(" seg", i-4));
//spine.addPair(ni4[7],ni[4],tgString("foot muscle seg", i) + tgString(" seg", i-4));
//spine.addPair(ni4[8],ni[2],tgString("foot muscle seg", i) + tgString(" seg", i-4));
//spine.addPair(ni4[8],ni[3],tgString("foot muscle seg", i) + tgString(" seg", i-4));
//spine.addPair(ni4[8],ni[6],tgString("foot muscle seg", i) + tgString(" seg", i-4));
//Trying out these for foot:
spine.addPair(ni4[5],ni[0],tgString("foot muscle seg", i) + tgString(" seg", i-4));
spine.addPair(ni4[5],ni[1],tgString("foot muscle seg", i) + tgString(" seg", i-4));
spine.addPair(ni4[5],ni[2],tgString("foot muscle seg", i) + tgString(" seg", i-4));
spine.addPair(ni4[5],ni[3],tgString("foot muscle seg", i) + tgString(" seg", i-4));
spine.addPair(ni4[0],ni[4],tgString("foot muscle seg", i) + tgString(" seg", i-4));
spine.addPair(ni4[0],ni[5],tgString("foot muscle seg", i) + tgString(" seg", i-4));
spine.addPair(ni4[0],ni[6],tgString("foot muscle seg", i) + tgString(" seg", i-4));
spine.addPair(ni4[0],ni[7],tgString("foot muscle seg", i) + tgString(" seg", i-4));
}
//Don't forget muscles connecting hips to feet!
// Create the build spec that uses tags to turn the structure into a real model
tgBuildSpec spec;
spec.addBuilder("rod", new tgRodInfo(rodConfig));
#ifdef USE_KINEMATIC
spec.addBuilder("muscle", new tgKinematicContactCableInfo(motorConfig));
#else
spec.addBuilder("muscle", new tgBasicActuatorInfo(muscleConfig));
#endif
// Create your structureInfo
tgStructureInfo structureInfo(spine, spec);
// Use the structureInfo to build ourselves
structureInfo.buildInto(*this, world);
// We could now use tgCast::filter or similar to pull out the
// models (e.g. muscles) that we want to control.
allActuators = tgCast::filter<tgModel, tgSpringCableActuator> (getDescendants());
// Notify controllers that setup has finished.
notifySetup();
// Actually setup the children
tgModel::setup(world);
children.clear();
}
/// The LayerRegion at this point of time may contain
/// surfaces of various types (internal/bridge/top/bottom/solid).
/// The infills are generated on the groups of surfaces with a compatible type.
/// Fills an array of ExtrusionPathCollection objects containing the infills generated now
/// and the thin fills generated by generate_perimeters().
void
LayerRegion::make_fill()
{
this->fills.clear();
const double fill_density = this->region()->config.fill_density;
const Flow infill_flow = this->flow(frInfill);
const Flow solid_infill_flow = this->flow(frSolidInfill);
const Flow top_solid_infill_flow = this->flow(frTopSolidInfill);
const coord_t perimeter_spacing = this->flow(frPerimeter).scaled_spacing();
SurfaceCollection surfaces;
// merge adjacent surfaces
// in case of bridge surfaces, the ones with defined angle will be attached to the ones
// without any angle (shouldn't this logic be moved to process_external_surfaces()?)
{
Polygons polygons_bridged;
polygons_bridged.reserve(this->fill_surfaces.surfaces.size());
for (Surfaces::const_iterator it = this->fill_surfaces.surfaces.begin(); it != this->fill_surfaces.surfaces.end(); ++it)
if (it->is_bridge() && it->bridge_angle >= 0)
append_to(polygons_bridged, (Polygons)*it);
// group surfaces by distinct properties (equal surface_type, thickness, thickness_layers, bridge_angle)
// group is of type SurfaceCollection
// FIXME: Use some smart heuristics to merge similar surfaces to eliminate tiny regions.
std::vector<SurfacesConstPtr> groups;
this->fill_surfaces.group(&groups);
// merge compatible solid groups (we can generate continuous infill for them)
{
// cache flow widths and patterns used for all solid groups
// (we'll use them for comparing compatible groups)
std::vector<SurfaceGroupAttrib> group_attrib(groups.size());
for (size_t i = 0; i < groups.size(); ++i) {
const Surface &surface = *groups[i].front();
// we can only merge solid non-bridge surfaces, so discard
// non-solid or bridge surfaces
if (!surface.is_solid() || surface.is_bridge()) continue;
group_attrib[i].is_solid = true;
group_attrib[i].fw = (surface.is_top()) ? top_solid_infill_flow.width : solid_infill_flow.width;
group_attrib[i].pattern = surface.is_top() ? this->region()->config.top_infill_pattern.value
: surface.is_bottom() ? this->region()->config.bottom_infill_pattern.value
: ipRectilinear;
}
// Loop through solid groups, find compatible groups and append them to this one.
for (size_t i = 0; i < groups.size(); ++i) {
if (!group_attrib[i].is_solid)
continue;
for (size_t j = i + 1; j < groups.size();) {
if (group_attrib[i] == group_attrib[j]) {
// groups are compatible, merge them
append_to(groups[i], groups[j]);
groups.erase(groups.begin() + j);
group_attrib.erase(group_attrib.begin() + j);
} else {
++j;
}
}
}
}
// Give priority to oriented bridges. Process the bridges in the first round, the rest of the surfaces in the 2nd round.
for (size_t round = 0; round < 2; ++ round) {
for (std::vector<SurfacesConstPtr>::const_iterator it_group = groups.begin(); it_group != groups.end(); ++ it_group) {
const SurfacesConstPtr &group = *it_group;
const bool is_oriented_bridge = group.front()->is_bridge() && group.front()->bridge_angle >= 0;
if (is_oriented_bridge != (round == 0))
continue;
// Make a union of polygons defining the infiill regions of a group, use a safety offset.
Polygons union_p = union_(to_polygons(group), true);
// Subtract surfaces having a defined bridge_angle from any other, use a safety offset.
if (!is_oriented_bridge && !polygons_bridged.empty())
union_p = diff(union_p, polygons_bridged, true);
// subtract any other surface already processed
//FIXME Vojtech: Because the bridge surfaces came first, they are subtracted twice!
surfaces.append(
diff_ex(union_p, to_polygons(surfaces), true),
*group.front() // template
);
}
}
}
// we need to detect any narrow surfaces that might collapse
// when adding spacing below
// such narrow surfaces are often generated in sloping walls
// by bridge_over_infill() and combine_infill() as a result of the
// subtraction of the combinable area from the layer infill area,
// which leaves small areas near the perimeters
// we are going to grow such regions by overlapping them with the void (if any)
// TODO: detect and investigate whether there could be narrow regions without
// any void neighbors
{
coord_t distance_between_surfaces = std::max(
std::max(infill_flow.scaled_spacing(), solid_infill_flow.scaled_spacing()),
top_solid_infill_flow.scaled_spacing()
);
Polygons surfaces_polygons = (Polygons)surfaces;
Polygons collapsed = diff(
surfaces_polygons,
offset2(surfaces_polygons, -distance_between_surfaces/2, +distance_between_surfaces/2),
true
);
Polygons to_subtract;
surfaces.filter_by_type((stInternal | stVoid), &to_subtract);
append_to(to_subtract, collapsed);
surfaces.append(
intersection_ex(
offset(collapsed, distance_between_surfaces),
to_subtract,
true
),
(stInternal | stSolid)
);
}
if (false) {
// require "Slic3r/SVG.pm";
// Slic3r::SVG::output("fill_" . $layerm->print_z . ".svg",
// expolygons => [ map $_->expolygon, grep !$_->is_solid, @surfaces ],
// red_expolygons => [ map $_->expolygon, grep $_->is_solid, @surfaces ],
// );
}
for (Surfaces::const_iterator surface_it = surfaces.surfaces.begin();
surface_it != surfaces.surfaces.end(); ++surface_it) {
const Surface &surface = *surface_it;
if (surface.surface_type == (stInternal | stVoid))
continue;
InfillPattern fill_pattern = this->region()->config.fill_pattern.value;
double density = fill_density;
FlowRole role = (surface.is_top()) ? frTopSolidInfill
: surface.is_solid() ? frSolidInfill
: frInfill;
const bool is_bridge = this->layer()->id() > 0 && surface.is_bridge();
if (surface.is_solid()) {
density = 100.;
fill_pattern = (surface.is_top()) ? this->region()->config.top_infill_pattern.value
: (surface.is_bottom() && !is_bridge) ? this->region()->config.bottom_infill_pattern.value
: ipRectilinear;
} else if (density <= 0)
continue;
// get filler object
#if SLIC3R_CPPVER >= 11
std::unique_ptr<Fill> f = std::unique_ptr<Fill>(Fill::new_from_type(fill_pattern));
#else
std::auto_ptr<Fill> f = std::auto_ptr<Fill>(Fill::new_from_type(fill_pattern));
#endif
// switch to rectilinear if this pattern doesn't support solid infill
if (density > 99 && !f->can_solid())
#if SLIC3R_CPPVER >= 11
f = std::unique_ptr<Fill>(Fill::new_from_type(ipRectilinear));
#else
f = std::auto_ptr<Fill>(Fill::new_from_type(ipRectilinear));
#endif
f->bounding_box = this->layer()->object()->bounding_box();
// calculate the actual flow we'll be using for this infill
coordf_t h = (surface.thickness == -1) ? this->layer()->height : surface.thickness;
Flow flow = this->region()->flow(
role,
h,
is_bridge || f->use_bridge_flow(), // bridge flow?
this->layer()->id() == 0, // first layer?
-1, // auto width
*this->layer()->object()
);
// calculate flow spacing for infill pattern generation
bool using_internal_flow = false;
if (!surface.is_solid() && !is_bridge) {
// it's internal infill, so we can calculate a generic flow spacing
// for all layers, for avoiding the ugly effect of
// misaligned infill on first layer because of different extrusion width and
// layer height
Flow internal_flow = this->region()->flow(
frInfill,
h, // use the calculated surface thickness here for internal infill instead of the layer height to account for infill_every_layers
false, // no bridge
false, // no first layer
-1, // auto width
*this->layer()->object()
);
f->min_spacing = internal_flow.spacing();
using_internal_flow = true;
} else {
f->min_spacing = flow.spacing();
}
f->endpoints_overlap = scale_(this->region()->config.get_abs_value("infill_overlap",
(unscale(perimeter_spacing) + (f->min_spacing))/2));
f->layer_id = this->layer()->id();
f->z = this->layer()->print_z;
f->angle = Geometry::deg2rad(this->region()->config.fill_angle.value);
// Maximum length of the perimeter segment linking two infill lines.
f->link_max_length = (!is_bridge && density > 80)
? scale_(3 * f->min_spacing)
: 0;
// Used by the concentric infill pattern to clip the loops to create extrusion paths.
f->loop_clipping = scale_(flow.nozzle_diameter) * LOOP_CLIPPING_LENGTH_OVER_NOZZLE_DIAMETER;
// apply half spacing using this flow's own spacing and generate infill
f->density = density/100;
f->dont_adjust = false;
/*
std::cout << surface.expolygon.dump_perl() << std::endl
<< " layer_id: " << f->layer_id << " z: " << f->z
<< " angle: " << f->angle << " min-spacing: " << f->min_spacing
<< " endpoints_overlap: " << f->endpoints_overlap << std::endl << std::endl;
*/
Polylines polylines = f->fill_surface(surface);
if (polylines.empty())
continue;
// calculate actual flow from spacing (which might have been adjusted by the infill
// pattern generator)
if (using_internal_flow) {
// if we used the internal flow we're not doing a solid infill
// so we can safely ignore the slight variation that might have
// been applied to f->spacing()
} else {
flow = Flow::new_from_spacing(f->spacing(), flow.nozzle_diameter, h, is_bridge || f->use_bridge_flow());
}
// Save into layer.
ExtrusionEntityCollection* coll = new ExtrusionEntityCollection();
coll->no_sort = f->no_sort();
this->fills.entities.push_back(coll);
{
ExtrusionRole role;
if (is_bridge) {
role = erBridgeInfill;
} else if (surface.is_solid()) {
role = (surface.is_top()) ? erTopSolidInfill : erSolidInfill;
} else {
role = erInternalInfill;
}
ExtrusionPath templ(role);
templ.mm3_per_mm = flow.mm3_per_mm();
templ.width = flow.width;
templ.height = flow.height;
coll->append(STDMOVE(polylines), templ);
}
}
// add thin fill regions
// thin_fills are of C++ Slic3r::ExtrusionEntityCollection, perl type Slic3r::ExtrusionPath::Collection
// Unpacks the collection, creates multiple collections per path so that they will
// be individually included in the nearest neighbor search.
// The path type could be ExtrusionPath, ExtrusionLoop or ExtrusionEntityCollection.
for (ExtrusionEntitiesPtr::const_iterator thin_fill = this->thin_fills.entities.begin(); thin_fill != this->thin_fills.entities.end(); ++ thin_fill) {
ExtrusionEntityCollection* coll = new ExtrusionEntityCollection();
this->fills.entities.push_back(coll);
coll->append(**thin_fill);
}
}