diff --git a/app/src/main/java/ru/ytkab0bp/slicebeam/components/bed_menu/BedMenuItem.java b/app/src/main/java/ru/ytkab0bp/slicebeam/components/bed_menu/BedMenuItem.java index f43c193..9be4d9b 100644 --- a/app/src/main/java/ru/ytkab0bp/slicebeam/components/bed_menu/BedMenuItem.java +++ b/app/src/main/java/ru/ytkab0bp/slicebeam/components/bed_menu/BedMenuItem.java @@ -85,6 +85,7 @@ public class BedMenuItem extends SimpleRecyclerItem { fragment.getGlView().arrange(); + fragment.getGlView().queueEvent(() -> { + if (fragment.getGlView().getRenderer().invalidateFlattenMode()) { + fragment.getGlView().requestRender(); + } + }); SliceBeam.EVENT_BUS.fireEvent(new NeedSnackbarEvent(R.string.MenuOrientationArrangeFinished)); }).setEnabled(fragment.getGlView().getRenderer().getModel() != null), new SpaceItem(portrait ? ViewUtils.dp(8) : 0, portrait ? 0 : ViewUtils.dp(8)), - new BedMenuItem(R.string.MenuOrientationPosition, R.drawable.menu_orientation_position_28).setEnabled(hasSelection()).onClick(v -> fragment.showUnfoldMenu(new PositionMenu(), v)), - new BedMenuItem(R.string.MenuOrientationRotation, R.drawable.menu_orientation_rotation_28).setEnabled(hasSelection()).onClick(v -> fragment.showUnfoldMenu(new RotationMenu(), v)) + new BedMenuItem(R.string.MenuOrientationFlatten, R.drawable.menu_orientation_position_28).setEnabled(hasSelection()).setCheckable((buttonView, isChecked) -> { + fragment.getGlView().getRenderer().setInFlattenMode(isChecked); + fragment.getGlView().requestRender(); + }, false), + new BedMenuItem(R.string.MenuOrientationPosition, R.drawable.menu_orientation_position_28).setEnabled(hasSelection()).onClick(v -> { + if (fragment.getGlView().getRenderer().resetFlattenMode()) { + fragment.getGlView().requestRender(); + ((BedMenuItem) adapter.getItems().get(2)).isChecked = false; + adapter.notifyItemChanged(2); + } + fragment.showUnfoldMenu(new PositionMenu(), v); + }), + new BedMenuItem(R.string.MenuOrientationRotation, R.drawable.menu_orientation_rotation_28).setEnabled(hasSelection()).onClick(v -> { + if (fragment.getGlView().getRenderer().resetFlattenMode()) { + fragment.getGlView().requestRender(); + ((BedMenuItem) adapter.getItems().get(2)).isChecked = false; + adapter.notifyItemChanged(2); + } + fragment.showUnfoldMenu(new RotationMenu(), v); + }) ); } + @EventHandler(runOnMainThread = true) + public void onFlattenModeReset(FlattenModeResetEvent e) { + ((BedMenuItem) adapter.getItems().get(2)).isChecked = false; + adapter.notifyItemChanged(2); + } + @EventHandler(runOnMainThread = true) public void onObjectsChanged(ObjectsListChangedEvent e) { ((BedMenuItem) adapter.getItems().get(0)).setEnabled(fragment.getGlView().getRenderer().getModel() != null); adapter.notifyItemChanged(0); - ((BedMenuItem) adapter.getItems().get(2)).setEnabled(hasSelection()); - adapter.notifyItemChanged(2); - ((BedMenuItem) adapter.getItems().get(3)).setEnabled(hasSelection()); - adapter.notifyItemChanged(3); + for (int i = 2; i <= 4; i++) { + BedMenuItem item = (BedMenuItem) adapter.getItems().get(i); + item.setEnabled(hasSelection()); + if (item.isCheckable) { + item.isChecked = false; + } + adapter.notifyItemChanged(i); + } } @EventHandler(runOnMainThread = true) public void onSelectionChanged(SelectedObjectChangedEvent e) { - ((BedMenuItem) adapter.getItems().get(2)).setEnabled(hasSelection()); - adapter.notifyItemChanged(2); - ((BedMenuItem) adapter.getItems().get(3)).setEnabled(hasSelection()); - adapter.notifyItemChanged(3); + for (int i = 2; i <= 4; i++) { + BedMenuItem item = (BedMenuItem) adapter.getItems().get(i); + item.setEnabled(hasSelection()); + if (item.isCheckable) { + item.isChecked = false; + } + adapter.notifyItemChanged(i); + } } public final class PositionMenu extends UnfoldMenu { diff --git a/app/src/main/java/ru/ytkab0bp/slicebeam/events/FlattenModeResetEvent.java b/app/src/main/java/ru/ytkab0bp/slicebeam/events/FlattenModeResetEvent.java new file mode 100644 index 0000000..c681df2 --- /dev/null +++ b/app/src/main/java/ru/ytkab0bp/slicebeam/events/FlattenModeResetEvent.java @@ -0,0 +1,7 @@ +package ru.ytkab0bp.slicebeam.events; + +import ru.ytkab0bp.eventbus.Event; + +@Event +public class FlattenModeResetEvent { +} diff --git a/app/src/main/java/ru/ytkab0bp/slicebeam/fragment/BedFragment.java b/app/src/main/java/ru/ytkab0bp/slicebeam/fragment/BedFragment.java index fae032a..74a1071 100644 --- a/app/src/main/java/ru/ytkab0bp/slicebeam/fragment/BedFragment.java +++ b/app/src/main/java/ru/ytkab0bp/slicebeam/fragment/BedFragment.java @@ -37,6 +37,7 @@ import ru.ytkab0bp.slicebeam.components.bed_menu.OrientationMenu; import ru.ytkab0bp.slicebeam.components.bed_menu.SliceMenu; import ru.ytkab0bp.slicebeam.components.bed_menu.TransformMenu; import ru.ytkab0bp.slicebeam.config.ConfigObject; +import ru.ytkab0bp.slicebeam.events.FlattenModeResetEvent; import ru.ytkab0bp.slicebeam.events.NeedSnackbarEvent; import ru.ytkab0bp.slicebeam.events.SlicingProgressEvent; import ru.ytkab0bp.slicebeam.navigation.Fragment; @@ -398,6 +399,10 @@ public class BedFragment extends Fragment { } private void selectMenu(Context ctx, boolean portrait, int slot) { + if (glView.getRenderer().resetFlattenMode()) { + glView.requestRender(); + SliceBeam.EVENT_BUS.fireEvent(new FlattenModeResetEvent()); + } isAnimatingMenu = true; BedMenu prevMenu = menuMap.get(currentMenuSlot); diff --git a/app/src/main/java/ru/ytkab0bp/slicebeam/render/GLRenderer.java b/app/src/main/java/ru/ytkab0bp/slicebeam/render/GLRenderer.java index 8a64a93..6504301 100644 --- a/app/src/main/java/ru/ytkab0bp/slicebeam/render/GLRenderer.java +++ b/app/src/main/java/ru/ytkab0bp/slicebeam/render/GLRenderer.java @@ -3,6 +3,7 @@ package ru.ytkab0bp.slicebeam.render; import static android.opengl.GLES30.*; import static ru.ytkab0bp.slicebeam.utils.DebugUtils.assertTrue; +import android.graphics.Color; import android.opengl.GLSurfaceView; import android.util.Log; @@ -72,6 +73,10 @@ public class GLRenderer implements GLSurfaceView.Renderer { private Vec3d rotate = new Vec3d(); private ArrayList raycastHits = new ArrayList<>(); + private Vec3d bbMin = new Vec3d(), bbMax = new Vec3d(); + private boolean isInFlattenMode; + private ArrayList flattenPlanes = new ArrayList<>(); + public Camera getCamera() { return camera; } @@ -165,6 +170,36 @@ public class GLRenderer implements GLSurfaceView.Renderer { } } + public boolean invalidateFlattenMode() { + if (isInFlattenMode) { + setInFlattenMode(true); + return true; + } + return false; + } + + public boolean resetFlattenMode() { + if (isInFlattenMode) { + setInFlattenMode(false); + return true; + } + return false; + } + + public void setInFlattenMode(boolean inFlattenMode) { + isInFlattenMode = inFlattenMode; + + for (int i = 0, c = flattenPlanes.size(); i < c; i++) { + flattenPlanes.get(i).release(); + } + flattenPlanes.clear(); + + if (isInFlattenMode) { + List planes = model.createFlattenPlanes(selectedObject); + flattenPlanes.addAll(planes); + } + } + @Override public void onDrawFrame(GL10 gl) { if (backgroundModel == null) return; // Not initialized yet @@ -266,12 +301,12 @@ public class GLRenderer implements GLSurfaceView.Renderer { if (selected) { shader.stopUsing(); - GLShaderProgram dash = GLShadersManager.get(GLShadersManager.SHADER_FLAT); + GLShaderProgram flat = GLShadersManager.get(GLShadersManager.SHADER_FLAT); glLineWidth(ViewUtils.dp(1.5f)); - dash.startUsing(); - dash.setUniformMatrix4fv("view_model_matrix", outModelMatrix); - dash.setUniformMatrix4fv("projection_matrix", projectionMatrix); + flat.startUsing(); + flat.setUniformMatrix4fv("view_model_matrix", outModelMatrix); + flat.setUniformMatrix4fv("projection_matrix", projectionMatrix); if (selectionModel == null) { selectionModel = new GLModel(); @@ -280,7 +315,30 @@ public class GLRenderer implements GLSurfaceView.Renderer { selectionModel.setColor(hoverColor); selectionModel.render(); - dash.stopUsing(); + flat.stopUsing(); + + shader.startUsing(); + } + + if (isInFlattenMode) { + shader.stopUsing(); + + GLShaderProgram flat = GLShadersManager.get(GLShadersManager.SHADER_FLAT); + + flat.startUsing(); + glEnable(GL_BLEND); + flat.setUniformMatrix4fv("view_model_matrix", outModelMatrix); + flat.setUniformMatrix4fv("projection_matrix", projectionMatrix); + + for (GLModel plane : flattenPlanes) { + boolean hoveringPlane = plane.isHovering; + int clr = ColorUtils.blendARGB(hoverColor, color, hoveringPlane ? 1 : 0); + plane.setColor(ColorUtils.setAlphaComponent(clr, (int) (Color.alpha(clr) * 0.75f))); + plane.render(); + } + + glDisable(GL_BLEND); + flat.stopUsing(); shader.startUsing(); } @@ -337,9 +395,55 @@ public class GLRenderer implements GLSurfaceView.Renderer { } } + if (isInFlattenMode && (j == selectedObject || j == -1)) { + int minPlane = -1; + double minDistancePlane = Double.MAX_VALUE; + + for (int i = 0, c = flattenPlanes.size(); i < c; i++) { + GLModel glModel = flattenPlanes.get(i); + glModel.getRaycaster().raycast(this, raycastHits, x, y); + + double minDistanceRay = Double.MAX_VALUE; + if (!raycastHits.isEmpty()) { + for (GLModel.HitResult res : raycastHits) { + double distance = res.position.distance(camera.position); + if (distance < minDistanceRay) { + minDistanceRay = distance; + } + } + } + if (minDistanceRay < minDistancePlane) { + minDistancePlane = minDistanceRay; + minPlane = i; + } + } + + if (minPlane != -1) { + GLModel glModel = flattenPlanes.get(minPlane); + model.flattenRotate(selectedObject, glModel); + model.getBoundingBoxExact(j, bbMin, bbMax); + model.translate(j, 0, 0, -bbMin.z); + + invalidateGlModel(selectedObject); + for (int k = 0, l = flattenPlanes.size(); k < l; k++) { + flattenPlanes.get(k).release(); + } + flattenPlanes.clear(); + + selectedObject = -1; + SliceBeam.EVENT_BUS.fireEvent(new SelectedObjectChangedEvent()); + return true; + } + + return false; + } + boolean render = j != selectedObject || j != -1; selectedObject = j == selectedObject ? -1 : j; if (render) { + if (isInFlattenMode) { + setInFlattenMode(false); + } if (selectedObject == -1) { selX = selY = selZ = 0; selRotX = selRotY = selRotZ = 0; @@ -386,6 +490,44 @@ public class GLRenderer implements GLSurfaceView.Renderer { } } + if (isInFlattenMode) { + int minPlane = -1; + double minDistancePlane = Double.MAX_VALUE; + + for (int i = 0, c = flattenPlanes.size(); i < c; i++) { + GLModel glModel = flattenPlanes.get(i); + glModel.getRaycaster().raycast(this, raycastHits, x, y); + + double minDistanceRay = Double.MAX_VALUE; + if (!raycastHits.isEmpty()) { + for (GLModel.HitResult res : raycastHits) { + double distance = res.position.distance(camera.position); + if (distance < minDistanceRay) { + minDistanceRay = distance; + } + } + } + if (minDistanceRay < minDistancePlane) { + minDistancePlane = minDistanceRay; + minPlane = i; + } + } + + if (minPlane != -1) { + for (int i = 0; i < flattenPlanes.size(); i++) { + flattenPlanes.get(i).isHovering = i == minPlane; + } + render = true; + } else { + for (int i = 0; i < flattenPlanes.size(); i++) { + if (flattenPlanes.get(i).isHovering) { + flattenPlanes.get(i).isHovering = false; + render = true; + } + } + } + } + return render; } @@ -499,5 +641,11 @@ public class GLRenderer implements GLSurfaceView.Renderer { glModels.get(i).release(); } glModels.clear(); + + isInFlattenMode = false; + for (int i = 0; i < flattenPlanes.size(); i++) { + flattenPlanes.get(i).release(); + } + flattenPlanes.clear(); } } diff --git a/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/Bed3D.java b/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/Bed3D.java index d828758..1518203 100644 --- a/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/Bed3D.java +++ b/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/Bed3D.java @@ -156,11 +156,19 @@ public class Bed3D { } public void release() { - Native.bed_release(pointer); - axes.release(); + if (pointer != 0) { + Native.bed_release(pointer); + axes.release(); + pointer = 0; // triangles.release(); // gridlines.release(); // contourlines.release(); + } + } + + @Override + protected void finalize() throws Throwable { + release(); } } diff --git a/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/GCodeProcessorResult.java b/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/GCodeProcessorResult.java index 59eb6a4..07f3e66 100644 --- a/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/GCodeProcessorResult.java +++ b/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/GCodeProcessorResult.java @@ -3,7 +3,7 @@ package ru.ytkab0bp.slicebeam.slic3r; import java.io.File; public class GCodeProcessorResult { - final long pointer; + long pointer; public GCodeProcessorResult(File f) { pointer = Native.gcoderesult_load_file(f.getAbsolutePath(), f.getName()); @@ -26,6 +26,14 @@ public class GCodeProcessorResult { } public void release() { - Native.gcoderesult_release(pointer); + if (pointer != 0) { + Native.gcoderesult_release(pointer); + pointer = 0; + } + } + + @Override + protected void finalize() throws Throwable { + release(); } } diff --git a/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/GCodeViewer.java b/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/GCodeViewer.java index 5be18e8..bff9905 100644 --- a/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/GCodeViewer.java +++ b/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/GCodeViewer.java @@ -65,7 +65,7 @@ public class GCodeViewer { } }; - private final long pointer; + private long pointer; public GCodeViewer() { pointer = Native.vgcode_create(); @@ -156,6 +156,14 @@ public class GCodeViewer { } public void release() { - Native.vgcode_release(pointer); + if (pointer != 0) { + Native.vgcode_release(pointer); + pointer = 0; + } + } + + @Override + protected void finalize() throws Throwable { + release(); } } diff --git a/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/GLModel.java b/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/GLModel.java index a8fa0b2..20fe8c7 100644 --- a/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/GLModel.java +++ b/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/GLModel.java @@ -5,7 +5,6 @@ import static ru.ytkab0bp.slicebeam.utils.DebugUtils.assertTrue; import android.graphics.Color; import java.util.ArrayList; -import java.util.List; import ru.ytkab0bp.slicebeam.render.Camera; import ru.ytkab0bp.slicebeam.render.GLRenderer; @@ -13,7 +12,7 @@ import ru.ytkab0bp.slicebeam.utils.Prefs; import ru.ytkab0bp.slicebeam.utils.Vec3d; public class GLModel { - private long pointer; + long pointer; private MeshRaycaster raycaster; public float hoverProgress; @@ -74,7 +73,10 @@ public class GLModel { } public void release() { - Native.glmodel_release(pointer); + if (pointer != 0) { + Native.glmodel_release(pointer); + pointer = 0; + } } public MeshRaycaster getRaycaster() { @@ -86,7 +88,7 @@ public class GLModel { } public final class MeshRaycaster { - public List raycast(GLRenderer renderer, ArrayList list, float x, float y) { + public void raycast(GLRenderer renderer, ArrayList list, float x, float y) { assertTrue(renderer != null); list.clear(); @@ -104,7 +106,6 @@ public class GLModel { new Vec3d(v[i + 3], v[i + 4], v[i + 5]) )); } - return list; } } diff --git a/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/GLShaderProgram.java b/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/GLShaderProgram.java index 91fb55b..6a18608 100644 --- a/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/GLShaderProgram.java +++ b/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/GLShaderProgram.java @@ -17,7 +17,7 @@ import ru.ytkab0bp.slicebeam.SliceBeam; import ru.ytkab0bp.slicebeam.utils.IOUtils; public class GLShaderProgram { - final long pointer; + long pointer; private static ThreadLocal matrixBuffer = new ThreadLocal() { @Nullable @Override @@ -140,6 +140,14 @@ public class GLShaderProgram { } public void release() { - Native.shader_release(pointer); + if (pointer != 0) { + Native.shader_release(pointer); + pointer = 0; + } + } + + @Override + protected void finalize() throws Throwable { + release(); } } diff --git a/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/Model.java b/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/Model.java index f863301..4bd6885 100644 --- a/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/Model.java +++ b/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/Model.java @@ -1,13 +1,15 @@ package ru.ytkab0bp.slicebeam.slic3r; import java.io.File; +import java.util.ArrayList; +import java.util.List; import java.util.UUID; import ru.ytkab0bp.slicebeam.utils.Vec3d; public class Model { public final String key = UUID.randomUUID().toString(); - final long pointer; + long pointer; private double[] boundingExact; private double[] boundingApprox; @@ -92,6 +94,10 @@ public class Model { Native.model_rotate(pointer, i, x, y, z); } + public void flattenRotate(int i, GLModel surface) { + Native.model_flatten_rotate(pointer, i, surface.pointer); + } + public int getObjectsCount() { return Native.model_get_objects_count(pointer); } @@ -128,12 +134,29 @@ public class Model { vec.set(tr[0], tr[1], tr[2]); } + public List createFlattenPlanes(int i) { + long[] ptr = Native.model_create_flatten_planes(pointer, i); + List list = new ArrayList<>(ptr.length); + for (long l : ptr) { + list.add(new GLModel(l)); + } + return list; + } + public GCodeProcessorResult slice(String configPath, String gcodePath, SliceListener listener) throws Slic3rRuntimeError { return new GCodeProcessorResult(Native.model_slice(pointer, configPath, gcodePath, listener)); } public void release() { - Native.model_release(pointer); + if (pointer != 0) { + Native.model_release(pointer); + pointer = 0; + } + } + + @Override + protected void finalize() throws Throwable { + release(); } public static Model merge(Model... models) { diff --git a/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/Native.java b/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/Native.java index e3cbd55..af936b4 100644 --- a/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/Native.java +++ b/app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/Native.java @@ -68,6 +68,8 @@ class Native { static native void model_translate_global(long ptr, double x, double y, double z); static native void model_scale(long ptr, int i, double x, double y, double z); static native void model_rotate(long ptr, int i, double x, double y, double z); + static native void model_flatten_rotate(long ptr, int i, long surfacePtr); + static native long[] model_create_flatten_planes(long ptr, int i); static native long model_slice(long ptr, String configPath, String path, SliceListener listener) throws Slic3rRuntimeError; static native void model_release(long ptr); diff --git a/app/src/main/jni/slicebeam/beam_native.cpp b/app/src/main/jni/slicebeam/beam_native.cpp index 64c5302..7f2c21b 100644 --- a/app/src/main/jni/slicebeam/beam_native.cpp +++ b/app/src/main/jni/slicebeam/beam_native.cpp @@ -11,6 +11,7 @@ #include "libslic3r/Geometry.hpp" #include "libslic3r/Arrange.hpp" #include "libslic3r/AABBMesh.hpp" +#include "libslic3r/Geometry/ConvexHull.hpp" #include "Viewer.hpp" #include "GLModel.hpp" @@ -26,6 +27,11 @@ using namespace Slic3r::GUI; #define TAG "SB_Native" +struct PlaneData { + std::vector vertices; + Vec3d normal; + float area; +}; struct ModelRef { Model model; std::string base_name; @@ -35,6 +41,7 @@ struct GLModelRef { TriangleMesh mesh; AABBMesh* emesh; std::vector normals; + Vec3d flatten_normal; }; struct ShaderRef { GLShaderProgram program; @@ -471,7 +478,37 @@ extern "C" { Vec3d vec(x, y, z); ModelVolumePtrs ptrs = model->model.objects[i]->volumes; for (int i = 0, c = ptrs.size(); i < c; i++) { - ptrs[i]->set_rotation(ptrs[i]->get_rotation() + vec); + Vec3d current_rotation = ptrs[i]->get_rotation(); + + Eigen::Quaterniond q_current = + Eigen::AngleAxisd(current_rotation[2], Eigen::Vector3d::UnitZ()) * + Eigen::AngleAxisd(current_rotation[1], Eigen::Vector3d::UnitY()) * + Eigen::AngleAxisd(current_rotation[0], Eigen::Vector3d::UnitX()); + + Eigen::Quaterniond q_delta = + Eigen::AngleAxisd(vec[0], Eigen::Vector3d::UnitX()) * + Eigen::AngleAxisd(vec[1], Eigen::Vector3d::UnitY()) * + Eigen::AngleAxisd(vec[2], Eigen::Vector3d::UnitZ()); + + Eigen::Quaterniond q_result = q_delta * q_current; + Eigen::Vector3d new_rotation = q_result.toRotationMatrix().eulerAngles(2, 1, 0); + ptrs[i]->set_rotation(Vec3d(new_rotation[2], new_rotation[1], new_rotation[0])); + } + model->model.objects[i]->invalidate_bounding_box(); + } + + JNIEXPORT void JNICALL Java_ru_ytkab0bp_slicebeam_slic3r_Native_model_1flatten_1rotate(JNIEnv* env, jclass, jlong ptr, jint i, jlong surface_ptr) { + ModelRef* model = (ModelRef *) (intptr_t) ptr; + GLModelRef* surface = (GLModelRef*) (intptr_t) surface_ptr; + + const Vec3d& normal = surface->flatten_normal; + ModelVolumePtrs ptrs = model->model.objects[i]->volumes; + for (int i = 0, c = ptrs.size(); i < c; i++) { + auto vol = ptrs[i]; + const Geometry::Transformation& old_transform = vol->get_transformation(); + const Vec3d tnormal = normal; + const Transform3d rotation_matrix = Transform3d(Eigen::Quaterniond().setFromTwoVectors(tnormal, -Vec3d::UnitZ())); + vol->set_transformation(old_transform.get_offset_matrix() * rotation_matrix * old_transform.get_matrix_no_offset()); } model->model.objects[i]->invalidate_bounding_box(); } @@ -537,6 +574,237 @@ extern "C" { return arr; } + JNIEXPORT jlongArray JNICALL Java_ru_ytkab0bp_slicebeam_slic3r_Native_model_1create_1flatten_1planes(JNIEnv* env, jclass, jlong ptr, jint i) { + ModelRef* ref = (ModelRef*) (intptr_t) ptr; + const ModelObject* mo = ref->model.objects[i]; + TriangleMesh ch; + Transform3d real_transform = Geometry::translation_transform(mo->bounding_box_exact().center()); + for (const ModelVolume* vol : mo->volumes) { + if (vol->type() != ModelVolumeType::MODEL_PART) + continue; + TriangleMesh vol_ch = vol->get_convex_hull(); + vol_ch.transform(vol->get_matrix_no_offset()); + vol_ch.transform(real_transform); + ch.merge(vol_ch); + } + ch = ch.convex_hull_3d(); + + std::vector m_planes; + + const Transform3d inst_matrix = mo->instances.front()->get_matrix_no_offset(); + + // Following constants are used for discarding too small polygons. + const float minimal_area = 5.f; // in square mm (world coordinates) + const float minimal_side = 1.f; // mm + + const int num_of_facets = ch.facets_count(); + const std::vector face_normals = its_face_normals(ch.its); + const std::vector face_neighbors = its_face_neighbors(ch.its); + std::vector facet_queue(num_of_facets, 0); + std::vector facet_visited(num_of_facets, false); + int facet_queue_cnt = 0; + const stl_normal* normal_ptr = nullptr; + int facet_idx = 0; + while (true) { + // Find next unvisited triangle: + for (; facet_idx < num_of_facets; ++ facet_idx) + if (!facet_visited[facet_idx]) { + facet_queue[facet_queue_cnt ++] = facet_idx; + facet_visited[facet_idx] = true; + normal_ptr = &face_normals[facet_idx]; + m_planes.emplace_back(); + break; + } + if (facet_idx == num_of_facets) + break; // Everything was visited already + + while (facet_queue_cnt > 0) { + int facet_idx = facet_queue[-- facet_queue_cnt]; + const stl_normal& this_normal = face_normals[facet_idx]; + if (std::abs(this_normal(0) - (*normal_ptr)(0)) < 0.001 && std::abs(this_normal(1) - (*normal_ptr)(1)) < 0.001 && std::abs(this_normal(2) - (*normal_ptr)(2)) < 0.001) { + const Vec3i face = ch.its.indices[facet_idx]; + for (int j=0; j<3; ++j) + m_planes.back().vertices.emplace_back(ch.its.vertices[face[j]].cast()); + + facet_visited[facet_idx] = true; + for (int j = 0; j < 3; ++ j) + if (int neighbor_idx = face_neighbors[facet_idx][j]; neighbor_idx >= 0 && ! facet_visited[neighbor_idx]) + facet_queue[facet_queue_cnt ++] = neighbor_idx; + } + } + m_planes.back().normal = normal_ptr->cast(); + + Pointf3s& verts = m_planes.back().vertices; + // Now we'll transform all the points into world coordinates, so that the areas, angles and distances + // make real sense. + verts = transform(verts, inst_matrix); + + // if this is a just a very small triangle, remove it to speed up further calculations (it would be rejected later anyway): + if (verts.size() == 3 && + ((verts[0] - verts[1]).norm() < minimal_side + || (verts[0] - verts[2]).norm() < minimal_side + || (verts[1] - verts[2]).norm() < minimal_side)) + m_planes.pop_back(); + } + + // Let's prepare transformation of the normal vector from mesh to instance coordinates. + const Matrix3d normal_matrix = inst_matrix.matrix().block(0, 0, 3, 3).inverse().transpose(); + + // Now we'll go through all the polygons, transform the points into xy plane to process them: + for (unsigned int polygon_id=0; polygon_id < m_planes.size(); ++polygon_id) { + Pointf3s& polygon = m_planes[polygon_id].vertices; + const Vec3d& normal = m_planes[polygon_id].normal; + + // transform the normal according to the instance matrix: + const Vec3d normal_transformed = normal_matrix * normal; + + // We are going to rotate about z and y to flatten the plane + Eigen::Quaterniond q; + Transform3d m = Transform3d::Identity(); + m.matrix().block(0, 0, 3, 3) = q.setFromTwoVectors(normal_transformed, Vec3d::UnitZ()).toRotationMatrix(); + polygon = transform(polygon, m); + + // Now to remove the inner points. We'll misuse Geometry::convex_hull for that, but since + // it works in fixed point representation, we will rescale the polygon to avoid overflows. + // And yes, it is a nasty thing to do. Whoever has time is free to refactor. + Vec3d bb_size = BoundingBoxf3(polygon).size(); + float sf = std::min(1./bb_size(0), 1./bb_size(1)); + Transform3d tr = Geometry::scale_transform({ sf, sf, 1.f }); + polygon = transform(polygon, tr); + polygon = Slic3r::Geometry::convex_hull(polygon); + polygon = transform(polygon, tr.inverse()); + + // Calculate area of the polygons and discard ones that are too small + float& area = m_planes[polygon_id].area; + area = 0.f; + for (unsigned int i = 0; i < polygon.size(); i++) // Shoelace formula + area += polygon[i](0)*polygon[i + 1 < polygon.size() ? i + 1 : 0](1) - polygon[i + 1 < polygon.size() ? i + 1 : 0](0)*polygon[i](1); + area = 0.5f * std::abs(area); + + bool discard = false; + if (area < minimal_area) + discard = true; + else { + // We also check the inner angles and discard polygons with angles smaller than the following threshold + const double angle_threshold = ::cos(10.0 * (double)PI / 180.0); + + for (unsigned int i = 0; i < polygon.size(); ++i) { + const Vec3d& prec = polygon[(i == 0) ? polygon.size() - 1 : i - 1]; + const Vec3d& curr = polygon[i]; + const Vec3d& next = polygon[(i == polygon.size() - 1) ? 0 : i + 1]; + + if ((prec - curr).normalized().dot((next - curr).normalized()) > angle_threshold) { + discard = true; + break; + } + } + } + + if (discard) { + m_planes[polygon_id--] = std::move(m_planes.back()); + m_planes.pop_back(); + continue; + } + + // We will shrink the polygon a little bit so it does not touch the object edges: + Vec3d centroid = std::accumulate(polygon.begin(), polygon.end(), Vec3d(0.0, 0.0, 0.0)); + centroid /= (double)polygon.size(); + for (auto& vertex : polygon) + vertex = 0.9f*vertex + 0.1f*centroid; + + // Polygon is now simple and convex, we'll round the corners to make them look nicer. + // The algorithm takes a vertex, calculates middles of respective sides and moves the vertex + // towards their average (controlled by 'aggressivity'). This is repeated k times. + // In next iterations, the neighbours are not always taken at the middle (to increase the + // rounding effect at the corners, where we need it most). + const unsigned int k = 10; // number of iterations + const float aggressivity = 0.2f; // agressivity + const unsigned int N = polygon.size(); + std::vector> neighbours; + if (k != 0) { + Pointf3s points_out(2*k*N); // vector long enough to store the future vertices + for (unsigned int j=0; jNewLongArray(m_planes.size()); + + // And finally create respective VBOs. The polygon is convex with + // the vertices in order, so triangulation is trivial. + for (int i = 0, s = m_planes.size(); i < s; i++) { + auto& plane = m_planes[i]; + indexed_triangle_set its; + its.vertices.reserve(plane.vertices.size()); + its.indices.reserve(plane.vertices.size() / 3); + for (size_t i = 0; i < plane.vertices.size(); ++i) { + its.vertices.emplace_back((Vec3f)plane.vertices[i].cast()); + } + for (size_t i = 1; i < plane.vertices.size() - 1; ++i) { + its.indices.emplace_back(0, i, i + 1); // triangle fan + } + + if (Geometry::Transformation(inst_matrix).is_left_handed()) { + // we need to swap face normals in case the object is mirrored + // for the raycaster to work properly + for (stl_triangle_vertex_indices& face : its.indices) { + if (its_face_normal(its, face).cast().dot(plane.normal) < 0.0) + std::swap(face[1], face[2]); + } + } + GLModelRef* ref = new GLModelRef(); + ref->mesh = TriangleMesh(its); + ref->model.init_from(its); + ref->flatten_normal = plane.normal; + ref->emesh = new AABBMesh(its, true); + ref->normals = its_face_normals(its); + + jlong ptr = reinterpret_cast(ref); + env->SetLongArrayRegion(arr, i, 1, &ptr); + + // vertices are no more needed, clear memory + plane.vertices = std::vector(); + } + m_planes.clear(); + return arr; + } + JNIEXPORT jlong JNICALL Java_ru_ytkab0bp_slicebeam_slic3r_Native_model_1slice(JNIEnv* env, jclass, jlong ptr, jstring configPath, jstring path, jobject listener) { try { ModelRef* model = (ModelRef*) (intptr_t) ptr; diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml index 8b86e19..f47d9ae 100644 --- a/app/src/main/res/values-ru/strings.xml +++ b/app/src/main/res/values-ru/strings.xml @@ -50,6 +50,7 @@ Ориентация Расст. модели Модели расставлены. + Поверхн. Позиция X Y diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 601e924..706e58f 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -52,6 +52,7 @@ Orientation Arrange models Models arranged. + Surface Position X Y