I've been having fun with this GUI library called Kivy lately.  I've been particularly interested in Kivy as it is cross platform to Windows, Mac, Linux, Iphone, Android and the Raspberry Pi. I think its only fair to share what I've learned, as I have had so much fun making a simple calclulator app. Following the documentation found on Kivy's website, I was able to port the application to my windows pc, linux pc, and my android cell phone. The only thing holding me back from Mac, is the lack of having one. The other main reason I feel the need to share about Kivy, is its ease of use. Kivy is its own language developed and dedicated to separating GUI code from procedural code.  Hands down, Kivy is my go to for rapid GUI programming, and I have a feeling it might be the same for you soon. 

1.) Kivy GUI language syntax -Layouts, Buttons, Labels, and other cool stuff 
2.)How to load the Kivy language into python - 3 ways
3.)Writing python code that will work with the calculator GUI
4.)Key Binding the keyboard to the Kivy calculator

This is a lot of stuff to cover, so I'm going to break this up into multiple blog posts. We will cover the basics of parts 1, 2, and 3 in this part of the tutorial. What you learn here can be applied directly, to making other programs. If your looking for a "one press of a button runs a function" kind of tutorial, you've found it. :p 
Just remember that you have to install kivy for this tutorial. Its a simple process though. Here is a link to that.

Kivy is a language dedicated to building GUI platforms for python applications. Applications made with kivy are cross platform, allowing you to create (with cross platform dependencies being kept in mind) on one operating system, and be able to run it on any other system, as is typical with most python programs. Kivy’s main focus is to separate the GUI side of programming from the function processing side of programming.

There are three ways to program with the kivy language. 
1.) The kivy language can be defined in a separate file with the ".kv" extension name. This separate file will be imported into your program.

2.) The language can be used directly with in the python file using an imported function from the kivy library (my preference as I don’t have to switch back and forth). We will be employing this method today. 

3.) The language can be skipped, and instead, can be used as a python import, similar to the way Tkinter, and every other module is used. In this case, one would have a seperate GUI.py file with all the commands necessary to construct the GUI. 

Terminology - If you are an experienced veteran, feel free to skip this part :)

Let’s get some basic terms out of the way:

GUI - Graphical User interface. We all have seen parts of the Matrix. Thinking back to that movie, I can remember the cool green text effect on the computer screens surrounding Neo. Every computer, at its core operation, is exactly like that, just a command prompt. The only thing separating us from having to work with that “green and black” text screen is called a Graphical User Interface. Long story short, somebody, somewhere said to themselves “hey, it’d be great if we didn’t have to type every single command in when working with these machines… maybe if we had pictures that we could click on or something…” and many years later, we ended up with the wonderful world of GUI based “point and click” systems that we have today. I understand this a broad simplification of GUI, but for the most part, will help you to understand the difference between GUI programming, and Command line programming.    

Widget - A widget is an object that represents a graphical portion of the screen. I know this sounds counterintuitive, but a widget does not have to be visible. A widget can refer to an invisible box on the screen. This invisible box can register touch input from a user, and refer it back to the python program for processing, like in the canvas of a paint application such as GIMP. These widgets interact with one another providing information based upon user input. This information is usually passed to methods that perform a calculation and then return the result back to the GUI for the user to view. Simply put, a widget can be a button, a field for user input, an image, a layout to place other widgets in, pretty much anything and everything. 

App - This refers to your program as a whole. You will see this terminology being used in kivy alot. An App will contain all of the widgets needed for your program to function. After programming the app, we can port it to windows, mac, linux, android and iphone, given that we make sure we have our dependencies met. 

Layout Widget: This type of widget holds others widgets. Typically speaking, there are different layouts based upon how the programmer wants the widgets to be displayed. We will create a Layout widget, and will place other widgets such as Button widgets, and Label Widgets within said Layout widget. We can even nest Layouts within Layouts. According to the Kivy programming guide, this can be done infinitely, with respect the horsepower of your PC. 

Button Widget: This type of widget is the most common. We have all seen buttons in programs, and almost every single GUI based program uses buttons as part of its main operation. There are many different types of buttons, but there main purpose is to allow a user to call a function (ie. Do something when pressed).

Label Widget: This type of widget will show the user some kind of information. We can assign a function to a Button Widget, and when it is pressed, we can update a Label widget to display the information found from the function. This is pretty much the process for 90% of programs. Don’t quote me on that number please. :p

TextInput Widget: This type of widget allows a user to input information. The information will be read as text. It can be multi line, or single line. This can be also used for inputting password information, and can be programmed to display stars instead of the inputted characters. 
*While we will not be using the TextInput widget in this tutorial, it is important to note, as these four Widgets will make up a large majority of basic GUI programs.* 

Now that we have that out of the way we can start some programming!

I’m going to be doing this on my windows platform, but you can still do this on linux as well. I haven’t tried it with a Mac, so I can’t vouch, but I see no reason why it can’t be done there as well.

If you need to install kivy still, there is a straight forward tutorial found here at kivy’s website. Its a simple process. If your completely new to kivy, still fresh with python, and want more of a “hold hands” tutorial, I'll be working on one for you, so check back shortly. :)

We are going to start by importing the widgets that we will use from the kivy library. 
We are going to be using the Layout, Button, and Label Widget. The structure for importing, is pretty much as listed above. We just import what we need. And if we are figuring it out as we go, then we will keep adding imports for all of the widgets that we are using, as we figure out whats needed. 

If you run the above code you will see a black box. This is the bear bone base for a kivy application. We have our imports, and at the bottom we have the section of code responsible for running our GUI.

For now I want to focus on two things. 

1.) the code

"Builder.load_string("""

""")

2.) the class being defined

class RootWidget(BoxLayout):

These two are the most vital portion of the program. In the Builder.load_string() we will place all of our kivy code here. This is where everything GUI is defined. This function will load our code, and will construct the GUI. 

The second RootWidget(BoxLayout): is where we will define all of our functions for the program to process/accomplish its goal. I.e. if we wanted a program that had a button, and printed "Hello", we would define the button portion within in the builder.load_string() function, and we would define the print("Hello") function with in the class we created called RootWidget()

Lets take a look at how that would be coded.

 

Inside the Builder.load_string() function we have the code 

<RootWidget>
   Button:
      on_press: root.printer()

This piece of code is the kivy language itself.

The code <RootWidget> tells kivy to look at our class, and inherits its base layout from there, which is a BoxLayout, as well as to look at our RootWidget() class for its functions.

The Button: code tells kivy to add a Button to our base layout.  

The on_press:root.printer() code tells kivy to look at our RootWidget class for a function named hello, and will call that function every time our button is pressed. The word "root" placed before printer() tells kivy to look at our RootWidget() class for the function named printer. Please note that there is no correlation between root and the class name RootWidget(). Ie. if you change RootWidget() to DavidsWidget(), the method of assigning the hello function will still read 

on_press: root.hello()

notice how the tabs signify which what feature is part of what. The on_press: is a part of the Button, and the Button is a part of the Root Widget. We can nest as many widgets as we want within in our <RootWidget>, but we can only have one <RootWidget>.  This one <RootWidget> is linked to our class, and our class is called through certain portion of code at the bottom of our script - return RootWidget().

The words "RootWidget" in this portion can be replaced with anything preferred, but the name of the class it inherits from must be named the same thing as well.
So if you change

<RootWidget>
to
<DavidsWidget> 

you must also change
class RootWidget(BoxLayout):
to
class DavidsWidget(BoxLayout): 


Now if we take our code, and place it back into the program we get some thing that looks like this.

That is the result of running the above code. Note how when you press it, the console runs our function that was defined within our class RootWidget(), and prints to the screen "Hello". This is the basic principle/building blocks for all kivy applications. Somewhat painless right? Now as we know the basics of Kivy, we can start working towards building real applications that are portable to all platforms. By following this series of tutorials you will have the ability to make applications just like this calculator, and much more, so stay tuned! :)

 

I fortunately walked to my mail box they other day to find that I received a check in the mail that I've been patiently waiting for. After giving it about five seconds worth of thought, I found myself thinking of a new computer.  I typically work on a lot of high end software, and I have been finding myself held back by the constraints of my computer (from 2008 lol). Now, I could get a modern day computer, with great video game  and general specs, OR.... I could go back a year or two, and get some powerful parts that are dedicated for a specific purpose (on top of getting the pricey software licenses needed for my fields). Those purposes for me are computer vision programming, machine learning, AI programming, CAD development, hardware/software engineering, game development, audio editing and video editing. So with out further stalling, I present to you the list of power house parts that went into this build. 

The parts and programs list for this workstation is as follows:
Two intel Xeon e5 2660 8 core processors (16 physical cores, 32 virtual cores with HT)
ASRock EP2C602-4L/D16 workstation motherboard
Two AMD firepro 7000 CAD graphics cards each with 4 gigs of ram, set in Crossfire config
AMD r390 fury with 8gbs RAM
128gb Samsung 1600mhz ram 
1 terabyte SSD samsung pro 
4 TB HDD toshiba NAS drive
Phanteks Enthoo Luxe Series PH-ES614L_BK  computer case 
1200w gold rated modular PSU by OCZ 
bluray burner with 128gb burning capacity
low latency bluetooth transmitter
usb 3.0 pcie card and front panel hub
pny 128gb flash drive usb 3.0 400Mbps read speed
thumbprint scanner 
4k monitor (swooped for 200 bucks on black Friday)
windows 8.1 pro full version
ableton live 9 suite (on sale through the bay, still hurts to pay it though)
Pycharm Professional for python programming
FluidMask3 (on sale)

These are the parts that I had saved up for and purchased before hand:
focusrite audio interface 
perception 120 microphone
aka mpk mini (I bought and repaired it for a little under 40 bucks)
bludio victory headphones
utech 12 button gaming mouse (set for CAD development)
Microsoft ergonomic keyboard
Corel Video studio ultimate x10
wondershare filmora (lifetime license)

Super awesome free software I'd like to give credit too:
FreeCAD - MY FAVORITE, used for making models of anything and everything
audacity - kick butt simple audio editor 
blender - awesome game character modeling software
unity - awesome videogame development software. (Free for the most part)
python (2.7 and 3.5) - my main programming language
arduino IDE

The list above accounts for about 90 percent of everything that has gone into this build. After everything was said and done, I had spent more than what I'd like, but recalling that I built my last computer in about '08/'09, and it is still working, I think its fair to say that I'm going to make this one last. This will also significantly speed up my research process. Having a power house that can virtualize multiple machines to compile code, while still allowing me to engineer through CAD, Ableton, VideoStudio, GIMP, Unity, Blender, PyCharm, and Filmora with out sacrificing the processing power I need is CRUCIAL to my line of work. This also gives me a little more motivation to hit the books, with determination. And to answer your question, yes I can (and will occasionally) use this play a video game or two. :p

    I'd like to welcome every one to Ineedmytech. I'll go ahead and start this blog, as and introduction to my background with computers. My name is David Jackson, and I am a college student studying for my Majors in Computer Science, Engineering, and Math. If time, and finances allow, I hope to major in chemistry as well, as I personally feel these four fields are so intertwined with one another, that it will only serve to benefit me in my pursuits. I have been working with computers ever since I was seven years old. I first started learning how to repair computers, and by the age of ten I had managed to disassemble, and reassemble my first computer, successfully, with out adult supervision. In my teen years, I started a small business selling candy in high school, and raised enough funds to create my first real gaming rig. This computer was made in 2008 and is still functioning, capable of playing 4k resolution video games. Currently, it serves as a backup lab computer though. *EDIT* I finally upgraded, and the new computer is listed in the super computer blog post if you wanna check that out. :)

    After high school, I began looking into developing technology, and I had made my first set of LED grow lights when I was nineteen. I was able to cultivate a small plant for several months, running the lights for periods of eight to ten hours every day. Here was when I realized I had a love for technology so I pursued my passions further. Looking online, I found all kinds of cool websites, wiki pages, and DIY projects. Among them I found an article on touch screen surfaces and decided this would be my next project. I managed to construct a fully functional 54" touch screen surface from a web camera, Plexiglas, infrared LED's, and a projector, with the help of a simple tutorial. It was capable of registering more than ten touch points, and had cost me less than two hundred dollars to make. At the time of making this touch screen, a similar sized model sold for over three thousand dollars. I won't lie, I felt pretty boss looking at the culmination of all the hard work put into this project. 

After this project, I felt the need to continue learning, so began to research into this magical thing called the Arduino. I had heard about this all over the net, and never had a chance to look into to yet. For those of you who are still learning about this, the arduino is a miniaturized computer that you can hook up to almost anything. This arduino can then be programmed to do anything you want. Its made to be completely customizable based upon the users needs. I had seen people making all sorts of gadgets, and thought immediately to myself  "Well....all that coding stuffs beyond me, I just like putting stuff together." Boy was I wrong. I've had "code fever" ever since I turned on an LED with the arduino. I spend every bit of time and money buying modules and circuits for this awesome little computer. I knew that even if I didn't know how to use them yet, in the future, I would figure it out. I felt confident in my use of this arduino micro controller, after making all kinds of cool stuff. I automated my room window with a wireless remote control.

 I made a turn table for 3D scanning objects. I even made a remote control car and terrorized my dog for hours. I learned much of C++ from first hand experience with programming the arduino. One of the cool things I worked on (and I swear I am not a nerd :p) was automating a life size BB8 starwars droid. I had a coworker who found a broken store display, and he brought it to me, hoping I could fix it. I worked on it for two months and redid all of the electronics inside of it. I automated the BB8 unit so that the head moves, plays sound, and flashes its "eyes" when some one walks by. The possibility with the arduino is pretty much endless.

    Now at this point in my technological endeavors, did I realize that I was stifled by my lack of computer programming knowledge, and so I sought to change that. I became certified in python programming through a course I found online. Upon doing so, I was eager to prove my certifications worth, so I began developing portfolio work. My first was an application that interacted with pay to click websites, as a proof of concept. The fact that the program made enough change to buy me a cup of coffee was only icing on the cake. :) I was able to use OpenCV to over ride CAPTCHA codes so that no human interaction was necessary, allowing my computer to click on advertisements all day, earning me passive income. I took this further, and ported the application to the Raspberry Pi (another MCU, with a littler more horsepower) for energy effeciency. I had it up, running and working, on a low cost platform, for several hours of the day before the administrators blocked my withdrawals. At this point, I decided to cut my efforts, and move on to learning other important libraries for Python. The libraries I had used for the project above were awesome, but I felt underdeveloped in the understanding of, so I started buying as many books, and courses as I could on python programming. After many months of frustration, and cups of coffee, I had developed my first GUI based program. It was a fully featured text editor, based off of the one found in the HotShotTkinter book from Bhaskar Chaudary. It works pretty much the same way the notepad found in Windows does.  It was an awesome experience, and feeling to have worked for months learning this library, and find that I can start making programs you'd find on your every day computer.

    I realized, from that experience, the value of consistently learning computer libraries for python (and other programming languages), so I set myself to learn something everyday, and after few more months, I had began to really grasp computer vision topics. I had made computers to recognize faces, track eye motions, track moving objects and specific colors, as well as recognize and classify types of different plants, according to the images given (I have to give credit to Adrian Rosebrock at PyImageSearch.com for helping with that). I could really start to feel the power surging every time I typed. It is an amazing feeling to know that you can make a computer do anything you need it to do, with the only limit being the creativity of the creator. That being said, I decided to throw myself into programs found at my local college, and long story short (the long story will be found in a later blog post :P) I ended up leading a team of student researchers to develop a satellite as a paid intern for NASA, and was recognized by U.S. congress for the work we did. We are currently publishing our work, and hope to have our satellite in space by 2018/19. I won't lie, the above project was the culmination of spending years learning, sifting, and wading through thousands of DIY articles and tutorials (in addition to help from my professors, and many others), so I felt called to start this blog, and share everything I have learned, in hopes of paying forward the creation process for my fellow makers, and lovers of tech. So with that, I welcome all readers to IneedMyTech, and hope that I may be of assistance to you all.

Thanks for your time, 
-David

The video below is a time lapse of me using FreeCAD to develop custom circuit boards.