evnL

[106-112] Weekly Grid

More boxes. Too many to be honest. As far as constructing boxes in one point perspective, I found that drawing the front and back faces first and then connecting them together produced the best the results. I will work on the rotated boxes exercise this week.

Code Patterns

Stop rewriting code you wrote before. Stop fixing bugs that you debugged before. Reuse code whenever you can. Copy and paste.

Would building a library of coding tools make me more competitive in coding competitions? The answer must be yes, since it can't possibly make me less competitive, right?

Linked Lists

Linked lists are extremely common. You could imagine them as the slime monsters of the coding world. I'll be farming some LeetCode style slimes for the next couple of days.

Copy LeetCode's linked list class in c++ and implement/demonstrate a simple print method for linked lists.

Finish all LeetCode linked list problems.

Implement rest of basic linked list methods (i.e. length, head, tail, copy, etc.). Include time and space complexity. Write both iterative and recursive solutions if available.

Stacks and queues.

Select and implement 2 LeetCode problems as cleanly as possible.

Sort.

Update: Admit it

I didn't complete the milestones that I set out to complete. No matter what excuses I may have, none will change that fact. While I could try my hardest to redeem myself, I would just be ignoring the true underlying problem.

Alright, what in the world prevented me from completing my milestones?

Milestone difficulty? The milestones are supposed to be easy and they are. I'm confident that I could complete the milestones one way or another, but the way I embarked on lacked the quality and flexibility I wanted. It was dirty on the outside and ugly on the inside, but it worked. I everntually caved and stopped working on milestones to bring up the quality. Now I have a system with unnecessarily good quality under the hood, which will help me in the future if I continue to use this system. But why did quality suffer while I was completing milestones in the first place?

Unfamiliar libraries and frameworks? Okay, I admit that unfamiliar libraries and frameworks did pose problems and probably alway will. With new tools, it's not always straight forward to find out what are the best or standard ways to use them, which will inevitably lead to degraded quality.

From here, I will work with the assumption that integrating new, unfamiliar tools is the root cause that prevented me from completing my milestones. Testing this hypothesis would involve completing milestones only with tools I'm very familiar with. While I can avoid new tools, the potential value of any future projects will suffer, since many projects rely on the value from preexisting tools. With projects of value in mind, I need to develop a tool learning process in order to gracefully integrate them into my projects. As for the projects themselves, I need to find projects where I can guarantee the highest quality.

Second Milestone

Plugin to draw n random points on a layer. 30 random points

Add a docker so I can control the number of points in Krita. Simple docker

Add feature to check the accuracy of the submitted memorized points.

A way to easily generate a new set of random points.

Figure out if multithreading is possible in Krita.

If possible, set timer to hide layer after t seconds. Else, clean up code.

I'm most likely not going to make a post for every milestone completed, but I don't see why not for now. The second milestone required me to look into Qt, which took up a large chunk of my time. Honestly, most of the trouble came from learning the necessary Qt to get the job done.

Resources used

QIntValidator

QLabel

QLineEdit

Layout Example

[99-105] Weekly Grid

Worked on box depth a bit.

Still working on lines.

Keep hand, arm, and shoulder loose.

Don't grip the pen too tightly.

Don't exert unnecessary force.

Don't trust your eyes when drawing a line.

First Milestone Completed

Plugin to draw n random points on a layer. 30 random points

Add a docker so I can control the number of points in Krita.

Add feature to check the accuracy of the submitted memorized points.

A way to easily generate a new set of random points.

Figure out if multithreading is possible in Krita.

If possible, set timer to hide layer after t seconds. Else, clean up code.

I completed my first milestone for Weekly Projects. Sure, the bar is low, but it is intentionally low.

As I was doing the milestone, I noticed a couple things.

First, the milestone was not specific (with respect to details) which is both a blessing and a curse. It's good because it allowed me to complete the milestone with minimal effort, but it's bad because I knew the implementation could be better. If I had tried to do this project without establishing the milestones first, I probably would have opted for the better, more time consuming implementation and risked not even finishing the project. I should definitely try to balance the generality and specificity of my future milestones when defining them next week. They should be specific enough so they don't cause problems in the future and general enough so they don't cause problems in the present.

Second, the time taken to complete this milestone was longer than expected. I have identified a couple fixable bottlenecks:

Documentation lookup time can be reduced by becoming more familiar with it.

Time wasted restarting Krita because of some Python error can be reduced by writing code correctly the first time.

Writing boilerplate code. Perhaps a plugin to generate it with a single click? (I copied and pasted my code from a plugin I wrote before which helped a little.)

Resources

Krita Python Plugin

Krita Scripting API

QByteArray for accessing and modifying layer data.

Default channels are BGRA one byte each.

First Step

Photographic memory (also called eidetic memory) is truly a remarkable ability. While most people believe that it is an innate talent, I believe it is a learnable skill. To be honest, I say virtually everything is a learnable skill. Anyways, photographic memory can be learned, and I'll attempt to learn it in order to draw more fluently. My reasoning being if the brain can see an image from memory, then the brain should also be able see an image from imagination. Once your brain can see the end result, drawing is effectively reduced to tracing.

I'll be developing and testing a series of visualization and tracing exercises for this project. The first of which is point memorization, which involves memorizing the positions of randomly scattered points in a 2D plane.

Implementations

I have roughly considered three possible implementations each with their own pros and cons. All of them are software based to eliminate setup time.

Web based. Javascript.

Pros. Portable. Easy to share. Flexibility.

Cons. Unaware of any drawing frameworks. Javascript typing.

Mobile/Tablet. Android.

Pros. Touch screens are nice. Flexibility.

Cons. Unaware of any drawing frameworks. Have to go through the whole app making process.

Krita. Python.

Pros. Already built a Krita plugin before. Already thought of the whole plan using Krita.

Cons. Limited to the Krita platform and by Krita. Conflicting hotkeys. Multithreading?

I'll be using Krita to start. I'll save the other implementations for later.

Milestones

Plugin to draw n random points on a layer.

Add a docker so I can control the number of points in Krita.

Add feature to check the accuracy of the submitted memorized points.

A way to easily generate a new set of random points.

Figure out if multithreading is possible in Krita.

The goal lies outside my comfort zone

The more I think about formally tackling Weekly Projects, the more uncomfortable I get. The same with writing. Plain discomfort. I guess the documentation that Weekly Projects requires doesn't come naturally to me. If it did, I would probably be doing Weekly Projects instead of planning out the whole challenge. But here I am not knowing how to say what I want to say.

Planning

Churning out weekly projects isn't a particularly new challenge; however, such an endeavor is, without a doubt, extremely difficult. For lack of a better example, I've attempted this challenge many times and failed many times over precisely because this challenge is not easy to do. After numerous attempts over the years, I have finally figured out a structured method that should reliably solve the challenge at hand.

Ideas

Each weekly project is a complete execution on an idea. Naturally, any idea worth executing needs to be able to generate value (preferrable immediate value), otherwise it's a waste of time. The idea needs to answer the following questions:

What problems does the idea attempt to solve?

Are these problems worth solving?

If the idea satisfactorily answers these two questions, then add that idea to the list. In order to get a sense of the idea's difficulty and scale, roughly plan out and collect possible methods and tools for the idea. Start with the easier ideas since they are typically yield more value per unit of effort.

Note: Ideas like art are never quite complete, so keep them in the list even after executing on them. They can always be improved upon.

Execution

The weekly in weekly projects means that an idea needs to be taken from start to finish in the span of seven days. The days don't necessarily have to be consecutive, but nonconsecutive days should be the exception rather than the norm.

In each day, make sure to complete one or more sessions, where a session is doing as much as you can in one sitting. The duration of one sitting varies. It should be long enough to get something done and short enough so burnout isn't as much of a risk. In my case, I'll be aiming for 45 minute uninterrupted sessions.

The content of each session in the entire week should preferably be determined in the first session of the week after choosing the idea. Each session should have a documentable milestone, and completing a session should mean its respective milestone has been reached.

In the beginning, session milestones need to be small, since it is imperative that they aren't missed. Later down the line, they will probably still seem small due to accumulated skill and experience. Session milestones are an opportunity to obtain what I call proof of progress. Want to maintain motivation throughout the week? Obtain proof of progress. Want to tell people about your cool ideas? Show them proof of progress. Proof of progress is more or less the magic behind continuous hard work as well as self validation.

One more thing. If only...

So far I've discussed ideas, sessions, milestones, and proof of progress in varying degrees. Those are all pieces of the weekly projects puzzle. Since the pieces are few, putting the pieces together is relatively straight forward. However, that assumes we have all the pieces in the right shapes beforehand. I'll discuss piece creation and sculpting at a later date. (To be honest, I haven't gotten those processes down to a science yet.) In the meantime, try doing weekly projects using the above method.

[92-98] Weekly Grid

More line practice I guess.

Ghosting lines really does build confidence.

Focused on correcting my posture by adjusting the distance between the page and my body. Page was too close to my body before.

Stopped doing image traces for now, because they lack focus as far as improving line accuracy and precision goes. It currently involves too much guessing and hoping that one out of many lines is good.

[85-91] Weekly Grid

Nothing interesting this week. Just lines.

I've been doing this for a few weeks and I'm beginning to wonder about what I can do about the least interesting parts of this exercise. Specifically, the part where I need to take a picture, transfer it to desktop, rotate, crop, convert to gray-scale, apply constrast, and upload. These steps actually take non-trivial amounts of time. So far there are two options that I have thought of.

The first option is to do everything digitally. This approach eliminates all but the last step which is actually pretty good. We can improve the last step by designing a plugin in Krita for even quicker uploads. The only reason -- this is probably a stupid reason -- that I'm avoiding this option is that I'm not comfortable drawing digitally yet. Now that I think about it, doing the exercise digitally will help with that. (Also I draw with my other hand when I draw digitally.)

The second option is to build a phone app that automates the all the steps. The technology exists already. I'll most likely still need to do the rotating and cropping manually. The rest of the tasks can be taken care of by stringing together features from existing apps.

[78-84] Weekly Grid

Still lost. The only things that I did were drawing through my boxes more and applying occlusion to suggest whether an edge of the box is in front or behind another edge.

[71-77] Weekly Grid

[64-70] Weekly Grid

The technique to draw dashed lines is pretty interesting. It helps to draw from the shoulder but, at the same time, the wrist and fingers. Definitely an exercise worth considering.

My cubes are starting to bend a bit. A step forward maybe?

For most of us who have taken a linear algebra or matrix course, thinking in vectors and matrices is pretty easy. For example, try imagining a point in space. We know almost intuitively that this point must have some coordinate \((x,y,z)\) relative to some origin. On the other hand, we have the quaternion which is commonly used in 3D systems for rotation. Currently, Wikipedia’s explanation of a quaternion is difficult to follow for anyone who’s not a mathematician, let alone imagine. But a quaternion doesn’t need to be difficult to understand, because it is actually a simple concept with interesting properties that most other people (math geeks) overemphasize.

What is a quaternion? It’s function or operations that takes a vector and outputs a vector. We can represent it in the form \(w+xi+yj+zk\).

What does it do? For quaternion \(w+xi+yj+zk\), it rotates a vector around the axis (\(x,y,z)\). It also scales the resulting vector by \(\sqrt{w^2+x^2+y^2+z^2}\), but that's not the interesting part.

How much does it rotate the vector? By \(2\tan^{-1}\left(\frac{\sqrt{x^2+y^2+z^2}}{w}\right)\) radians counter-clockwise with respect to the direction the axis is pointing (i.e. axis is pointing towards the viewer).

Bonus: What is a quaternion that gets from vector \(\vec{a}\) to vector \(\vec{b}\)? There are actually an infinite number of answers, but the simplest one is to first set \(w = 0\) and \[ (x,y,z) = \frac{1}{2}\left(\text{norm}(\vec{a}) + \text{norm}(\vec{b}) \right). \] This will rotate \(\vec{a}\) to the direction of \(\vec{b}\), but the magnitude will be incorrect. To correct this, we normalize our quaternion and multiply by the magnitude of \(\vec{b}\) over \(\vec{a}\). The intuition behind this is to first create an isosceles triangle by normalizing \(\vec{a}\) and \(\vec{b}\). This allows us to easily bisect the angle between the vectors. Finally, rotating 180 degress around the bisecting line by setting \(w = 0\) and scaling appropriately will achieve our desired result. The method also takes care of edge cases where we can't create the isosceles triangle.

[57-63] Weekly Grid

More boxes... The good news is I'm using boxes in more complex ways. The bad news is that my boxes are still too sloppy with regards to right angles and equal length lines in perspective.