Tutorial Art Design: writing

The Enemies of Growth - by Jessica Lanan

Over the years I have encountered a few creatures dwelling in my mind that can impede growth. Fortunately, these critters can be trained and kept in check. Below are my field notes from my experiences with the three most common species.

The Ego (Vanus Fragilis)

Habitat: Your mind
Diet: Flattery and attention
Habits: Strictly solitary

The Ego is a sensitive soul. It craves reassurance and takes failure quite personally. Desperate to convince itself that it is valuable, the Ego and will avoid situations where failure might occur. "Don't enter the contest, don't send the manuscript!" the Ego will plead, because it's easier to say I didn't try than I didn't succeed.

Unfortunately for the Ego, failure is a necessary part of growth. We learn the most when we push ourselves out of our comfort zones and try new things. The best way to succeed is to increase our failure rate, and the best way to learn is to face our failures head on and look at what worked, what didn't, and why.

Tips for Tempering an Ego:

Avoid overfeeding. Egos gorge themselves on attention.
Cultivate gratitude.
Remember: The Ego is not you—it just lives in your mind.
Set up a nice little Ego-cage in the back of your mind where it can stay out of the way.
Stay away from junk foods like flattery, which lead to a bloated and irritable Ego.

The Critic (Incuso Virosa)

Habitat: Your Mind
Diet: Negativity
Habits: Venomous. Often nocturnal, brings up worries at bedtime.

A wild Critic can lash out at your work (or life in general) with potent venom. “You aren’t talented enough,” the Critic will whisper in your ear. “Look at this other person’s work. It’s so much better.” The Critic will dredge up your mistakes and mockingly parade them before your eyes at your moment of greatest weakness.

As terrible as it sounds, A Critic can be helpful if it is trained to come out only when needed. The Critic is handy when deciding which thumbnail composition is better and why, or editing that manuscript in the second draft. But if it starts telling you that everything you make is garbage or that you’re not nearly as good as so-and-so, it’s time to go back in the kennel.

Tips for Coping with a Critic:

Use a muzzle to keep it from biting
Feed it as little negativity as possible.
Don’t let the Critic’s words become your own.
It’s okay to tell it to settle down. (Yes, out loud. Try it, I dare you!)
Critics shy away from laughter and fun. Remember fun?
Surround yourself with positive, encouraging people.

The Sloth (Choloepus Languidus)

Habitat: Your Mind
Diet: Inactivity
Habits: None

The sloth really wants you to succeed. It does. But it would rather not give up its Netflix marathons and surfing Facebook on its phone.

The Sloth is the creature that will tell you that your first thumbnail is good enough. Why bother trying other compositions? It will discourage you from taking those figure drawing classes you need, because that sounds like a lot of work after all. If you have a feeling that you need to work on your craft but you never seem to get around to doing it, you might be contending with one of these creatures.

Not to worry! Sloths can be trained. When properly employed, a Sloth can stop you from becoming a perfectionist, particularly on the projects that just aren’t worth the time. If you’re getting paid a pittance for an illustration, it probably isn't time to make the Mona Lisa. All it takes to train a Sloth is a little bit of priority shifting and the adoption of some new habits.

Tips for Training a Sloth:

Track your time and identify distractions.
If online distraction is a problem, you can use LeechBlock (Firefox) or StayFocused (Chrome) to limit the sites you can visit during specific times.
Put your phone out of reach and turn off notifications.
Force yourself to work on a project for just 20 minutes. Chances are good that the Sloth will slink away as you start to have fun with the project.
Work at a consistent time. Find a schedule that works for you.

In a Nutshell:

If you have a Critic, Ego or Sloth, don't beat yourself up over it. It's normal! Identify the species that is impeding your growth the most, and take a small step this week to help tackle it.

----

Jessica Lanan is a children's book writer and illustrator living in Boulder, Colorado. See more of her work at jessicalanan.com, on facebook or twitter.

For Those Who are Not Cinderella

If you’re an unpublished or aspiring author or illustrator, this post is written for you. If you have attended a few conferences or follow publishing blogs and the like, you may have come across at one point or another a story that goes about like this:

“Meet Jane Doe. Jane Doe was a totally unknown talent. Then one day, on a whim, she sent her manuscript/portfolio to [insert name of extremely famous and talented agent or editor.] Suddenly she became a whirlwind success! She was perfect! Her work was perfect! Everyone loved her! Her manuscript was immediately sold to the highest bidder and she subsequently won the Caldecott medal. And all that under the age of 30! Amazing!”

This story usually follows with something along these lines:

“Aspiring writers and illustrators will find her story very uplifting and inspirational."

Now, this is kind of the opposite of how I would expect that story to make people feel. If you ask me, I think aspiring writers and illustrators want to hear about how hard work and perseverance pays off, not about some insanely talented person's fairytale story. Usually the fairytale story makes you feel like you ought to just give up and go jump off a bridge.

However, people who want to devote their lives to making books for children (or at least the ones I know, with the conspicuous exception of myself) seem to be delightful human beings. If they feel envious they don’t show it. Before long they pick themselves up, look their friend in the eye and say, “I’m so happy for you! That’s really wonderful that you are an overnight sensation and have twelve book deals.” They smile and clap for their friends and go home and feel grateful that at least they can use their rejection letters to heat the house over the winter and save on utilities.

Feeling envious is normal. I’m convinced that most everyone does it, and if they claim that they don’t, it’s either because they’ve been very lucky and had a Cinderella-success-story of their own, or because they are lying. Those who can be extremely gracious and happy for the success of others are just more adept at letting go of the negative feelings. The important thing is is not to feel guilty for being jealous. Just accept that it’s a feeling that happens, and move on.

After all, these universal human feelings we struggle with are just the stuff of which great stories are made. Nobody wants to read about a perfect character who is gracious and charming and ideal in every way. It would be utterly bland. If you think about it, Cinderella is rather one-dimensional. What mistake did she ever make? How can a real person, full of faults, relate to her? Characters need imperfections, heroes need demons to conquer. Don’t hate yourself for your darker moments, just learn from them, and let them go so they don’t hold you back.

And just remember that if you ever end up on a stage giving a keynote address about your success, tell the audience what they need to hear: that you got to where you are by working hard, by not giving up, and by truly loving what you do.

They will love you for it.

----
Jessica Lanan is a children's book illustrator living in Boulder, Colorado. See more of her work at jessicalanan.com, on facebook or twitter.

PYTHON / Additional Examples and Usages of XML

In previous post, I talked a lot about XML and probably some of you got confused on how we can really use this XML writing and reading knowledge to do export import of data.

This is fine because with the XML Read and Write, you really have a lot of concepts to digest:

Using Element Tree XML built in module
Concept of XML: tag, element
Using File function of Python to write out to file
Using and constructing data that is like Dictionary: keys, items, values
Data type conversions
Understanding of Path Location of XML file in your Operating Systems

This XML concept is also still fairly new to me and I only understand the basic to write out the XML style format and read it back in.

Take it easy and slowly with this XML. See the pattern.

However as we know, even the basic knowledge can be really useful. I will further expand the idea from previous post. Feel free to ask me questions if you don't have clue what I am talking about.

DIY Write & Read of XML

For this, I will start by copying and pasting the template construct from previous post on XML and modify it slightly each time for each example below. It would be better to understand the xml.etree module, but we could also simply use the construct as long you know what it does in the background.

We will definitely use some simple BPY to collect information and data we needed to export about the 3D scenes. Our focus is on how the data can flow out of Blender and bring it in back into Blender or to other 3D packages.

Remember that Python scripting, like any other programming language, is something you learn and master by actually practicing it and making mistake and fixing it.

If you understand my style of blog writing, I actually improvise while writing. Often I do not actually plan the topic. This blog is more like Journal. I explore certain feature, I am testing and documenting each steps and then I will write it down. I guess you could do the same thing.

Hopefully with this examples, you can start to get curious and try your own XML export import.

It will get easier every time you try it yourself. My examples are there to assist you. Try doing the same thing without looking at my examples and you will start to understand.

Keep digging the Python language and Python in Blender, it will be worth it.

EXAMPLE 1: XML Transform Information (Position, Rotation, Scale) of objects

The idea is to get the Name, Translations, Rotations and Scales data of every selected objects and writing it out as XML. Below is such example of code. It can be optimized, but below should work and the code is pretty easy to read.

Maybe I have bunch of Boxes in random Position, Rotation, Scale in Blender that I want to export out as XML data.

WRITE OUT:


'''
Taken from: Blender Sushi Blog
Code by:  Jimmy Gunawan
Last update: 20130420
'''





import bpy
from xml.etree import cElementTree as ElementTree

# PRETTY PRINT
# function to pretty print the XML code
def prettyPrint(element, level=0):
    '''
    Printing in elementTree requires a little massaging
    Function taken from elementTree site:
    http://effbot.org/zone/element-lib.htm#prettyprint

    '''
    indent = '\n' + level * '  '
    if len(element):
        if not element.text or not element.text.strip():
            element.text = indent + '  '

        if not element.tail or not element.tail.strip():
            element.tail = indent

        for element in element:
            prettyPrint(element, level + 1)

        if not element.tail or not element.tail.strip():
            element.tail = indent

    else:
        if level and (not element.tail or not element.tail.strip()):
            element.tail = indent

    return element

### Collecting some information data about the scene ###

# In this example we collect the selected object Transforms
# aka Position (Translation/Location), Rotation, and Scale XYZ
# and writing out the data as XML format

# Create ROOT node
rootNode = ElementTree.Element('world')

# Get Selected Objects
selected_objects = bpy.context.selected_objects

for object in selected_objects:
    myLocs = object.location
    myRots = object.rotation_euler
    myScales = object.scale
    
    # Create node = CHILD element
    elementNode = ElementTree.Element('{object}'.format(object=object.name))
    
    # Parent CHILD node to ROOT
    rootNode.append(elementNode)

    # Adding attribute translations
    elementNode.attrib['TX'] = str(myLocs[0])
    elementNode.attrib['TY'] = str(myLocs[1])
    elementNode.attrib['TZ'] = str(myLocs[2])
    
    # Adding attribute rotations
    elementNode.attrib['RX'] = str(myRots[0])
    elementNode.attrib['RY'] = str(myRots[1])
    elementNode.attrib['RZ'] = str(myRots[2])
    
    # Adding attribute scales
    elementNode.attrib['SX'] = str(myScales[0])
    elementNode.attrib['SY'] = str(myScales[1])
    elementNode.attrib['SZ'] = str(myScales[2])

    # Adding text
    elementNode.text = '{object}'.format(object=object.name)


### WRITING OUT IN A CLEAN WAY IS A BIT COMPLEX... WE USE THE PRETTY PRINT

# Pretty print the rootNode
prettyPrint(element=rootNode)

# We need to convert to STRING before we can see the whole thing
xmlText = ElementTree.tostring(rootNode)

# FINAL RESULT, we need to append the HEADER
print ( '<?xml version="1.0" ?>\n{xmlText}'.format(xmlText=xmlText) )

### NOW WE LIKE TO WRITE OUT THE XML TO FILE
outputPath = r'C:\pythonInBlender\transOut.xml'

fileObject = open(outputPath, 'w')
fileObject.write('<?xml version="1.0" ?>\n' + xmlText.decode('utf8'))
fileObject.close()

print('XML file has been written in here: {outputPath}'.format(outputPath=outputPath))

THE XML:

READ IN:


'''
Taken from: Blender Sushi Blog
Code by:  Jimmy Gunawan
Last update: 20130420
'''





import bpy

from xml.etree import cElementTree as ElementTree

xmlPath = 'C:/pythonInBlender/transOut.xml'

xmlRoot = ElementTree.parse(xmlPath).getroot()


def applyTransform():

    for element in xmlRoot:

        # Get the NAME of objects
        objectName = element.tag
        print(objectName)
        
        # Tell Blender to get the current object data by its name
        object = bpy.data.objects['{objectName}'.format(objectName=objectName)]
        print(object)

        # Get all element keys
        myKeys = element.keys()
        # print(myKeys)

        # Get Position, Rotation and Scale data            
        posX, posY, posZ = float(element.get('TX')), float(element.get('TY')), float(element.get('TZ'))
        rotX, rotY, rotZ = float(element.get('RX')), float(element.get('RY')), float(element.get('RZ'))
        scaleX, scaleY, scaleZ = float(element.get('SX')), float(element.get('SY')), float(element.get('SZ'))

        # Apply Position, Rotation and Scale data to corresponding object by its name
        object.location = posX, posY, posZ
        object.rotation_euler = rotX, rotY, rotZ
        object.scale = scaleX, scaleY, scaleZ
            
applyTransform()

The code above is very specific about Object Name and that is just one way we can do this. If for the same objects we reset their position, we can then run the script and magically put them back into positions specified from XML.

The above example is not particularly amazing example because we can achieve the same thing using DAE Collada Export Import, for example. Although with DAE, we usually have limited options and flexibility.

We could bring the XML data to other 3D package and actually do ANYTHING with it. Keep in mind that the World XYZ Orientation might be different in other package.

This kind of code is probably good for saving out "Presets"or maybe "Character Poses". I have not looked at it deeply. It has potential for Assembly script. Although Blender File System and Referencing are actually already pretty cool and we can probably do the script based on that system. But if we want to bring it outside and inside other package, then XML seems to be nice.

From the above basic example, we can take the concept to place some Monkeys in the 3D scene, if we can think of every Cubes as Bounding Box:

READ IN, BUT CAST AS MONKEYS:


'''
Taken from: Blender Sushi Blog
Code by:  Jimmy Gunawan
Last update: 20130420
'''





import bpy

from xml.etree import cElementTree as ElementTree

xmlPath = 'C:/pythonInBlender/transOut.xml'

xmlRoot = ElementTree.parse(xmlPath).getroot()


def createMonkeyFromData():

    for element in xmlRoot:

        objectName = element.tag

        if 'TX' in element.keys():

            # Get Position Data            
            posX, posY, posZ = float(element.get('TX')), float(element.get('TY')), float(element.get('TZ'))

            # Create Suzanne based at position XYZ
            bpy.ops.mesh.primitive_monkey_add( location=(posX, posY, posZ) )
            
            monkey = bpy.context.selected_objects[0]
            print (monkey)
            
            # Get Rotation and Scale data
            rotX, rotY, rotZ = float(element.get('RX')), float(element.get('RY')), float(element.get('RZ'))
            scaleX, scaleY, scaleZ = float(element.get('SX')), float(element.get('SY')), float(element.get('SZ'))
            
            # Rotate and Scale monkey accordingly from data
            monkey.rotation_euler = rotX, rotY, rotZ
            monkey.scale = scaleX, scaleY, scaleZ
            
 
createMonkeyFromData()

NOT EXACT DIMENSION SIZE
We apply the Transform data from the Cubes into the Monkeys, although is not really the accurate Bounding Box or Dimension data. Because some parts of the monkey is poking out.

If you are questioning about it.We could export out the Dimension data as XML from the first place and apply it to the monkeys to get more accurate result.

Example on how to get dimension data of object to pass on:
bpy.data.objects[{object_name}].dimensions
bpy.data.objects['Cube'].dimensions

EXAMPLE 2: Reading In Custom Attribute Data

Let say we have XML data with arbitrary Custom Attribute and values. We did not create the date from Blender. Someone else did it. Maybe we grab the data from the Internet.

The XML data can be anything:
1. Yahoo! Weather XML data
City Location
Temperature High
Temperature Low
Today's Date
2. Facebook XML data
Person's Name
Person's Photo
Person's Age
Person's Likes
3. Google Map data
Latitude
Longitude
Name of State
etc
What we can do is simply READING those data and then visualizing it in Blender. 

A simple example, XML like below:

<world>

<Object1 COLOR="red" SIZE="5.0"/>

<Object2 COLOR="green" SIZE="2.0"/>

<Object3 COLOR="blue" SIZE="0.5"/>
</world>

OR MORE PROPERLY:

<?xml version="1.0" ?>
<world>
  <Object1 COLOR="red" SIZE="5.0"></Object1>
  <Object2 COLOR="green" SIZE="2.0"></Object2>
  <Object3 COLOR="blue" SIZE="0.5"></Object3>
</world>

(Save the bottom one as customData.xml.)

Ok, let say from those data, I will apply it to the Monkey.001, Monkey.002, and Monkey.003 objects in the 3D scene that I have prepared.

The Suzanne Three Sisters
What I am trying to do is to tell Blender:
Object1 --> Monkey.001 --> apply SIZE, apply MATERIAL with Diffuse Color = COLOR
Object2 --> Monkey.002 --> apply SIZE, apply MATERIAL with Diffuse Color = COLOR
Object3 --> Monkey.003 --> apply SIZE, apply MATERIAL with Diffuse Color = COLOR

The script can be as below:


READ IN CUSTOM XML
'''


Taken from: Blender Sushi Blog


Code by:  Jimmy Gunawan


Last update: 20130420


'''





import bpy

from xml.etree import cElementTree as ElementTree

xmlPath = 'C:/pythonInBlender/customData.xml'

xmlRoot = ElementTree.parse(xmlPath).getroot()


def applyColorToMonkey():

    for element in xmlRoot:
        
        # Create Materials with Color based on the NAME  
        colorname = element.get('COLOR')
        mat = bpy.data.materials.new(name='{colorname}'.format(colorname=colorname))
        
        # Create our own custom dictionary of color
        colorDict = {'red':[1.0,0.0,0.0], 'green':[0.0,1.0,0.0], 'blue':[0.0,0.0,1.0]}
        
        # Assign specified Diffuse Color into Material
        myColor = colorDict.get(colorname)
        bpy.data.materials[colorname].diffuse_color = myColor
        
        # Get the NAME of objects
        objectName = element.tag
        objectNumber = int(objectName.strip('Object'))
        monkeyName = 'Monkey.{objectNumber:03}'.format(objectNumber=objectNumber)
        
        print (monkeyName)
        
        # Tell Blender to get the monkey data by its name
        object = bpy.data.objects['{monkeyName}'.format(monkeyName=monkeyName)]
        
        # Assign our Material to corresponding Monkey
        object.data.materials.append(mat)
            
def applyScaleToMonkey():

    for element in xmlRoot:

        # Get the NAME of objects
        objectName = element.tag
        objectNumber = int(objectName.strip('Object'))
        monkeyName = 'Monkey.{objectNumber:03}'.format(objectNumber=objectNumber)
        
        print (monkeyName)
        
        # Tell Blender to get the monkey data by its name
        object = bpy.data.objects['{monkeyName}'.format(monkeyName=monkeyName)]
        
        print(object)

        # Get SIZE data and assign it to Scale Variables        
        scaleX, scaleY, scaleZ = float(element.get('SIZE')), float(element.get('SIZE')), float(element.get('SIZE'))

        # Apple Scale to Monkeys
        object.scale = scaleX, scaleY, scaleZ


applyColorToMonkey()
applyScaleToMonkey()







If the above code run as planned, we are getting something like below. This is the power of XML and Python and Python in Blender. 

We should be able to:
Write XML data (free the data to the ouside)
Read XML data (from any source)
Process the data
Apply the data

The code above can be further cleaned up and probably expanded
Error Checking
Check if object exist
Making sure Blender does not keep generating same Material Name when we run the script multiple times.
FURTHER ON WITH XMLSee if you can play with the idea further more:
Assigning "specific Texture Name" for each Material to be assigned into "specific" objects
Procedurally generate XML data 
Can we perhaps use other tool like Processing to generate XML and then bring it into Blender?
Turn it into Animation, let say if we have XML data in corresponding to Frame Number.
Find some XML data from Internet and bring it into Blender and visualize it.
Almost "Real time" XML data with refresh?

OTHER VIDEO TUTORIAL RELATED TO XMLLuiz Kruel @Eat3D
http://eat3d.com/free/maya_python

Based from his video tutorial, below is the converted Blender Script that does the XML export using MINIDOM.

from xml.dom.minidom import Document
import bpy

doc = Document()

root_node = doc.createElement("Blender Scene Info")
doc.appendChild(root_node)

# Get selected objects
selection = bpy.context.selected_objects

# Just print out selected objects name
for num, item in enumerate(selection):
    print (num, item.name)

# Add into XML tree:

for object in selection:
    object_node = doc.createElement(str(object.name))
    root_node.appendChild(object_node)

    object_locX = object.location.x
    object_locY = object.location.y
    object_locZ = object.location.z
    object_node.setAttribute("locationX", str(object_locX))
    object_node.setAttribute("locationY", str(object_locY))
    object_node.setAttribute("locationZ", str(object_locZ))
    
print()
print()
print()

xml_file = open("C:/test.xml", "w")
xml_file.write(doc.toprettyxml())
xml_file.close()

print ( doc.toprettyxml() )

Labels

Movies Post

Sports

Music

Business

Pictures

728x90 AdSpace

Travel

Fashion

Design

Movies

Recent Videos

Labels

Category

Slider

Recent Post

Games

Popular Posts

Pages

Find Us On Facebook

Links

About Me

Technology

Breaking News

The Ego (Vanus Fragilis)

The Critic (Incuso Virosa)

The Sloth (Choloepus Languidus)

In a Nutshell:

DIY Write & Read of XML

EXAMPLE 1: XML Transform Information (Position, Rotation, Scale) of objects

WRITE OUT:

READ IN, BUT CAST AS MONKEYS:

EXAMPLE 2: Reading In Custom Attribute Data

READ IN CUSTOM XML

FURTHER ON WITH XML

OTHER VIDEO TUTORIAL RELATED TO XML

MKRdezign

Contact Form