tbinias / heekscnc Goto Github PK

When the user clicks on a block of text in the NC Code window, the relevant
drawing items will be highlighted.
When the user clicks on some drawing items belonging to the NC Code item,
the relevant NC Code block will be selected.

remove any existing references to solid sim from HeeksCNC source code.
make a simbackplot.py, deriving from backplot.py which makes a nccode.xml
with extra information about moving parts required for a solid simulation.

Use a reordered sketch for writing to the script file,

This will be a child of program

I saved the sample zigzag file with dx = 0.1, but now it is 0.0!

reading in the xml file and making it into an NCCode object is too slow.

maybe it's something to do with appending to the text control?

Make Geoff's geometry into a stand-alone Python pyd file called kurve.pyd
The program will need to define kurves with language like:
k1 = kurve.new(0, 0)
kurve.add_line(k1, 10, 0)
kurve.add_arc(k1, "acw", 20, 20, 10, 10)

It will then need functions like
kurve.offset(k1, k2, 2.0)
kurve.copy(k1, k2)
num_spans = kurve.num_spans(k1)
sp, x, y, i, j = kurve.get_span(k1, i) first is i == 1

Make a "machining" toolbar.
We can keep the toolbars on the "Program" window and the "Output" window,
for now.

It shouldn't matter what name you name the folder HeeksCNC.
Also, it shouldn't matter where you put it on your computer.
HeeksCAD knows where it is, when it loads the dynamic library.
When it loads the dynamic library, it should pass the folder it is in to
the OnStartUp function.

Add a "machine" icon under the "program" icon in the tree view.

This will have the python module name of the machine "nc.iso" for example.

Also, it will have the name of the output file "output\test.tap"

When an operation is added, the tree should expand to show the user where
it is in the tree view

The NC Code window will have a "Save" button.
This will save the NC code file and then reload it using backplot to make
the nc-code object.

In Ubuntu, clicking on the toolpath in the graphics window, highlights the
correct NC code in the output window, but if the line of code is not in the
window, you can't see it.

It should scroll so you can see the code.

What steps will reproduce the problem?
1. using kurve to generate outside profile
2.
3.

What is the expected output? What do you see instead?
I'm getting several zero length arcs that end up being cut as inside loops
into the (simulated) part.

What version of the product are you using? On what operating system?
r 289 ubuntu 8.04

Please provide any additional information below.
I will attach file

The output window will be changed to be a NC Code window.
It will show the current NC-Code object as multi-coloured text.

The "Operations" object ( child of "Program" ) can be deleted. This should
not be possible.

When the user presses post-process, a post.py file should be written and
called with ShellExecute, or whatever the wx equivalent is.
This post.py will be able to create the NC code when run from Python,
independant from HeeksCNC.
Running post.py will then create the NC file.

backplot.py should then be called to make nccode.xml

HeeksCNC will then create a NC-Code tree item from nccode.xml

Where a pocketing area splits into two ( like in an hour-glass shape ), the
tool must get from one region to the other by travelling along a
neighbouring contour.
Currently, it just goes in a straight line from one contour to the next,
this can cut through the part!

There are already optional start and end roll-on and roll-off points,

But what's needed, too, is optional start and end points, so you can cut a
small section of a sketch, or start in a different place.

Add a tree icon to do adaptive roughing.

This will use the actp library from http://code.google.com/p/libactp/

The program window's tools will be simplified.
There will be no destinction between "run" and "post".
There will be one "G0" button which will ShellExecute post.py.
It will then ShellExecute backplot.py.
It will then tell the call the function which clears out the program's
nc-code object and makes a new one from the nccode.xml, made by backplot.py.

If something fails in the post processing script, it doesn't tell you.

When post-processing starts, it should delete the old output file.
When back-plotting starts, it should delete the old backplot file.

Remove Python from Voxelcut, instead make it able to read an xml file into
a CNCCode structure. This will be a copy of the CNCCode class used in
HCNCCode for the tree view.
HeeksCNC will be able to ShellExecute Voxelcut with a given xml file.

The NC Code window will have an "Open" button which will allow the user to
open an NC code file.
When the user opens an NC code file, it will actually call the function
that calls backplot.py and clears the program's nc-code object and makes a
new one from the nccode.xml file generated.

Currently sketches with islands are classed as "bad", and pocketing refuses
to do them.

Add a new order "WithIslands" or something, in GetSketchOrder(), and allow
pocketing, but don't allow profile operations yet.

There should be a simple Python script operation.
It will simply have a title and contain text that gets added to the main
Python script.

Add an object type to do zig zag machining

properties are:

list of solids to cut
tool ( diameter and corner radius )
direction ( x or y )
double minx, maxx, miny, maxy,
z0, z1, dx, dy

It will write pycam code, like this
        pg = DropCutter(c, model)
        pathlist = pg.GenerateToolPath(x0, x1, y0, y1, z0, z1, dx, dy, 0)

Please add a "clearance height" parameter to zig zag operation.

Currently it is hard-coded to 20

Changing tool type to "spherical" or "cylindrical" should hide "corner radius"

Setting the tool type to Toroidal Cutter, causes this to be output:

c = ToroidalCutter(1.500000, Point(0,0,7))

and I get this error

  File "/home/dan/Desktop/HeeksCAD/HeeksCNC/post.py", line 20, in <module>
    c = ToroidalCutter(1.500000, Point(0,0,7))
NameError: name 'ToroidalCutter' is not defined

see HeeksCAD issue http://code.google.com/p/heekscad/issues/detail?id=67

We need to make a machine class.
There will be a current machine.

machine will be used to derive all the post processor machines.

It will also be able to be derived to divert moves, a dropcut_machine maybe?

There should be an option for user type:

1. Tree Program editor
   Enable "Operations" icon in tree
     editing the tree, recreates the python script
   Read only "Program" window
     pressing "Post-process" creates the NC code ( and backplots it )
   Read only "Output" window
   Disable all buttons on "Output" window

2. Script Program editor
   No "Operations" icon in tree
   Enable "Program" window
     pressing "Post-process" creates the NC code ( and backplots it )
   Read only "Output" window
   Disable all buttons on "Output" window

3. NC Program editor
   No "Operations" icon in tree
   Clear and disable "Program" window
   Editable "Output" window
   Enable all buttons on "Output" window ( add a "Refresh graphics" button,
to do backplotting )

On changing user mode, this will set the default to be this option and "New
File" will be done automatically ( this may ask the user to save the file )

New file will set the option to the default.

On opening a file, the user type option should be set just for this
session, depending on what data is in the program ( if "Operations" exists,
set to "tree editor", else if python script exists, set to "script editor",
else if nc code exists, set to "NC editor", else use default option. )

open the attached arect1.heeks
Press "Py"
Press "G0"

The toolpath has unexpected internal loops at the left hand side!

An NC-Code object is needed.
This will be created by calling backplot.py, which will will make
nccode.xml, which will be used to create an NC-Code object.
This xml file will be the same format that the NC-Code object is saved as
in the heeks file.

[deleted issue]

Make HeeksCNC build for Ubuntu

There will be a "Cut selected sketches" button, which will add the relevant
text to the program. It will first show the user a dialog with options like
tool diameter, clearance height, final depth, rapid down to depth,
feed-rates, spindle speed.

If the user edits the Python program, they should be told that these
changes will be overwritten again, if they press the "Py" button.
Sam thing applies to the NC code and the "G0" button.

In Ubuntu, on a German computer.
Make a rectangle.
Press "Pocket"
Press "Py"

The script contains lines like
 final_depth = float(-0,2)

but it should be
 final_depth = float(-0.2)

It should be a '.' instead of a ','

A Profile is a graphical entity representing Geoff's Kurve.

This needs a tool bar button, and a conversion tool to create one from
lines and arcs.

Make sure ID numbers are generated correctly.

Make sure it saves and loads from xml file.

Linux - Clicking in NC code is not higlighting the text

The pocket operation needs a "direction" option which can be either "climb
( CW )" or "conventional ( CCW )".

There will be a button added to the program window's tool bar that will add
all the relevant text to the program to perform an area clearance of the
selected sketches.
It will show a dialog with things like tool diameter, clearance height,
final depth, maximum step-down, step-over, rapid-down-stop-before-hitting
distance, feedrates, spindle speed.

backplot.py needs to be written
This will be a class that can be derived from.
It will make "nccode.xml" by reading the NC code file.
It will probably be best to use an existing Pyhton parser to help with this.

It should describe how to use the different operations.
It can probably link to the .png files in the source code HeeksCNC/bitmaps.

Remove Anders' drop cutter code and put it in a Python module.

Make a python class derived from machine.
There will be a function
attach_start("somefile.stl", 0.1, 1)
This will remember the current machine and replace it with a
drop_cutter_machine.

Any subsequent feed, rapid moves, will be redirected to here, split and
made relative to the stl file height and then passed on to the original
machine.

there will be a function
attach_end()
to set the current machine back to the original machine

The z depth is always 0.

There should not be allowed multiple programs.

If the user selects the program, "Copy" is availabe. It shouldn't be available.

There should be options for "nested pockets", which can be done "pocket at
a time" or "level at a time"

The area module should have a pocket_offset which takes this option, aswell
as normal offset options, and returns a list of sorted areas