How should the files of TIIMP be saved? (Note: An option to enable/disable archiving will be added)
User created files as protected programs, internal files (Settings, etc.) as appvars
 20%  [ 2 ]
Everything as appvars
 80%  [ 8 ]
Everything as protected programs
 0%  [ 0 ]
Other (Please tell me what you mean!)
 0%  [ 0 ]
Total Votes : 10

Oh, I am sorry!
lirtosiast wrote:

//Get the polynomial coefficients

Input "Steps:",S




This works perfectly. I will need to make a hardcoded, fast preview version and an accurate but slower rendering version.

Thanks and sorry again!
Nik: I don't know why you apologize when the bug was mine.

PT_: This code that you posted earlier...

code = Input Z
      real(12,1,95,0,95,63,1    # draw vert white line from (95,0) to (95,63); update
      StorePic 2
      real(12,7,Ans+1,0,96,64,1 #draw white rectangle; (Ans+1,0) to bot right; update
      StorePic 1
      real(3,2,0,1,1            # recall pic 2 by overwrite; update; full screen
      If Ans
      real(12,7,0,0,Ans-1,64,1  # draw white rect; top left to (Ans-1,64); update
      real(4,3,1,1              # scroll screen right by 1px and update
      real(3,1,2,1,1            # recall pic 1 by OR; update; full screen

seems to be implementing a sort of 16.16 fixpoint math in TI-BASIC. From the page you linked to, it seems like there was a different algorithm that uses float math. Since the point of using fixpoint math was to speed up the algorithm, and integer math is just as slow as float math in TI-BASIC, and multiplying by 65536 is also slow, I think you should just use float math.

I don't understand these library commands, but do you need to update the LCD with every command? Doesn't that slow it down?
The library commands are explained here.

Also, the flag argument to update/not update the screen may be omitted for not updating it (means that nothing=update, "0"=don't update), which I believe speeds the code up more than the updating routine slows it down Wink...
But, seriously, I think omitting this argument and saving 2 bytes is simply worth the few milliseconds that it costs.
So, over the next few days (about a week or so) I will have no Internet connection again, as I will not be at home, celebrating with friends. I decided, since this project will be slightly harder without community help, I will back it up on my PC, reset my calculator and start a new project which I was planning for a long time now (even longer than TIIMP)...

When I get back home, depending on the progress, I will probably make a topic for it.
If I notice that it won't work, however, I will just abandon it...

So, see you and I wish you a happy new year!
Necrobump with good news today! Very Happy

Me and PT_ decided to pick up this project again!
Well, first sorry for having dropped that project. I still have no calculator (See signature), but I will use jsTIfied and Wabbitemu instead.

Kerm suggested reusing this topic, and as a free bonus we can loot it for some useful code.

We completely started over with the program, I guess I will edit the first post in this topic to contain the new information.

The changes we will do boil down to a fully external structure, meaning the only thing done by the main program is calling subroutines, and to an installer, which was already planned, but which can be improved due to that subroutine structure: We can allow installation of algorithm/function "packages" which allows the user to select precisely what functionality he wants to have in the program.
For example: Consider there are the packages "Shapes", "Scaling", "Dithering".
They would contain the algorithms for
- Drawing rectangles and circles in various colors (Filling/Outline)
- Enlarging and shrinking by various factors (Fast x2/Slow any scale) and various sizes (Full/Partial)
- Different dithering techniques for different results

And so on. ^ These are, by the way, planned.

Also, absolutely no promises here, but PT_ said that he could maybe port it to the CE. NO guarantees, especially since I said that and not him.

On my plans/progress:
- I did do the main program. It is only a shell, and will probably be reworked a hundred times, but I have a working base.
- I am fighting with xLib for making the GUI work. There will be no main menu screen - wastes memory and is in fact unnecessary. The main menu interface will be pop-out in the working canvas.
- Many of the algorithms may be reused
- Now, that PT_ knows Asm (Even really well, huge respect from me!), we can create Asm shortcuts for the most time consuming and time critical tasks. I will, however, use this sparingly. Could've done it all in Asm otherwise.
- Distant future: May be ported to Asm by PT_, and maybe, should I ever learn Asm, with my help. Just as uncertain as the CE port.

See the first post in this topic for a progress log, which I will create in a minute.
The last few days were pretty busy!
We fully planned the installer, PT_ made a good preview of the planned pseudo-GUI and I made some progress on the GUI subroutines.

Some screenshots:
The installer GUI, demonstrating the process of selecting algorithm packages

The program itself, with working GUI popout/hide functions so far.

Sorry for the graphical artefacts, no idea where they come from. haven't seen them while testing the code, must be some screenshot glitch.
I hadn't had much time lately, but still made some slight progress.
Basically, with the main program and many of the GUI subroutines done, I have almost finished the basic functionality. Another challenge will be to add layer support, but I think that should be doable.
The area selection algorithm will then just create a layer named "Selection" or "Mask" or something like that, but in essence just use the layer mechanic. (Yeah, that's details, but important ones. I had to think quite for a long time on how to do it, before I came up with this.)

The installer is planned to use a custom made compression algorithm for the unused packages. I checked a few algorithms and I believe assigning a variable number of nibbles to the tokens and then use a sort of Huffmann Encoding will be the best way of compressing it. Not sure on this, though, I will have to test it out with PT_.

The next big planned step will be implementing the algorithms themselves. That shouldn't be hard, the program will work as follows:
The main program waits for a keypress, then, depending on what key was pressed, passes it either to the GUI subprogram or to the algorithms subprogram or updates the cursor position.
Assuming it was the algorithm subprogram, it now has access to cursor, to the selected tool/filter, to the pressed key, to the layers and L1 which is temporary allocated for that algorithm.
It can then draw something on any layer, store something in the list, perform calculations, manipulate layers, ...

  • Basic functionality done
  • Installer will use compression, worked out how
  • Worked out how exactly the algorithms will work

Note that any feedback, suggestions, requests and whatever comments are welcome!
I'm surprised I missed this, but those screenshots look really great! I also like the naming, "TIMP" Razz
Okay, I couldn't work the last few days, as they were pretty busy...
Packing for vacancies, and such.
We will depart either on Saturday or on Sunday, and we will be in Croatia for anything between two and three weeks.

I really wish I could take a calculator along (Sad), but unfortunately, I have to stop development for that time. When school starts, though, I will have more time. (Sounds counterintuitive, I know.)
Nik, the project is cool. It doesn't matter to pause the development.

In holidays, I use to take the TI-84+SE and the Casio fx-9750GII in my laptop briefcase.
Sorry for the really slow progress, it's a problem of time (PT_ has no time at all, I have only little), mood (Personally I am tired and sometimes upset) and it poses challenges, not as simple as it seemed.
Anyway, the project is not dead, just progressing really slowly.

Let me explain how the thing works / will work:

Nik (Yes, me) wrote:
This is the master program, but just a shell. At startup it loads all assets to RAM (possibly will decompress them) and on program end it cleans up.
During execution, it controls the whole program flow, calls GUI routines via TIIMPGUI and controls tool algorithms, GUI algorithms, key inputs and tracks the cursor.
Basically depending on what key(s) you press it starts up a GUI subroutine, or passes the data to TIIMPALG for use for the algorithm.

This is the program that carries all GUI functions. It controls all GUI rendering and manages the GUI storage, cache and flags. Basically an all-in-one I/O manager.
It renders all menus, popups and other GUI elements, caches the screen, gets data from TIIMP and passes data back. It also manages some shared data, for example the currently active tool, or the state of the GUI.
Some parts are calling the same program again, when a data management routine (for example generating menu data) calls a rendering routine (for example rendering the menu).

This is the program that brings life to the machine - here are all actual graphics processing algoritms. It handles all graphical calculations and rendering, being called by TIIMP and calling TIIMPGUI for I/O functionality.
It has some allocated variables for use by the algorithms, plus it gets data passed from TIIMP and TIIMPGUI (the key presses, cursor, currently active tool).
Based on this data, the chosen algorithm performs a calculation and renders the results.
The allocated variables allow for extreme flexibility, as it allows for multiple prompts (stores in lists), multiple layers (stores in picture vars), etc.

This is not quite part of the whole thing, but still really important.
When you download the program, you get TIIMPINS and and tons of appvars of (possibly compressed) data. What TIIMPINS does is, it allows you to select which packages of algorithms you need, and installs only those, to save you memory. This is important due to the sheer size of TIIMPALG and the urgent need to cut it down - that way you merely install what you need.

I hope to finish another part on the weekend which will bring me far enough to release the code, finally. No functionality yet, but the only thing left will be the installer and the tools themselves.
So, guess what? I got a new calculator! Smile

Anyway, this is awesome, and plus I can work on it at school now... And plus, I just got more time since the first wave of tests is done! (The next one approaches, but I have enough time for now.)

I have had a challenge with implementing the menu GUI (Hey, it is pure basic and scrollable!), but I think I know how to solve that. Not really elegant, but fairly fast.

Well, long story short, I think I am able to finish it today, then test the parts that rely on it. If it all works by the evening, I'll post the code and corresponding screenshots today!
I am sorry to say it, but today, me and PT_ made the decision of abandoning this project... Sad

The thing is, we didn't have much time lately, and the community showed little interest in it.

I thank everyone for their patience and work, and I may once pick it up again - I am not deleting any code.

The project certainly has taught me things, and by stopping it, I get more room for applying this knowledge in new projects. In fact, I even know what I will do next - let it be a surprise for now! Wink

Thanks and sorry again.
Don't forget to take it out of your sig
Register to Join the Conversation
Have your own thoughts to add to this or any other topic? Want to ask a question, offer a suggestion, share your own programs and projects, upload a file to the file archives, get help with calculator and computer programming, or simply chat with like-minded coders and tech and calculator enthusiasts via the site-wide AJAX SAX widget? Registration for a free Cemetech account only takes a minute.

» Go to Registration page
Page 4 of 4
» All times are UTC - 5 Hours
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum