I’m thinking about developing some applications for iPhone. I’ve never code anything for Mac, so starting this trip to IPhone, the first stop is ObjC/Cocoa. Here I have collected some information I found useful for  C++ programmer to start coding ObjC .

Concepts Translation

Method declaration & Messages

Declaration / Message

The following table shows several examples of method declaration and method invocation = messaging

If you replace - with + in the declaration, then the instance method becomes a class methods

NSObject

Main methods implemented by NSObject

Simple Object/Class Declaration

FILE: MyObject.h

#import <Foundation/Foundation.h>

@interface MyObject : NSObject {
   // Declare instance variables
   // Basic types allocation is managed by the compiler
   int m_value;
   // Class instances are always managed through pointers
   // Allocation is a coder responsability
   NSString *m_string;
}

// Declare methods
- (int) getValue;
- (void) setValue: (int) value;
- (NSString *) getString;
- (void) setString: (NSString *) string;
 @end

Simple Object/Class Definition

#import "MyObject.h"
@implementation MyObject

// Define methods
- (int) getValue
{
   // Compiler returns this value doing a copy
   return m_value;
}

- (void) setValue: (int) value
{
   // Compiler manages the copy of basic types variables
   m_value = value;
}

- (NSString *) getString
{
   // We just return a pointer, not a copy of the class instance
   return m_string;
}

- (void) setString: (NSString *) string
{
   if (string)
   {
      // We tell the memory manager we have just finished using m_string instance
      [m_string release];

      // We point to the new string and tell the memory manager
      // that we are going to use the instance we have receive
      m_string = [string retain];
   }
}

@end

Intializers. Object instance creation

1. Allocation
2. Constructor/Initializer

Following code shows who create an object instance. Take a look at the ObjC message nesting syntax.
MyString *myString = [[MyString alloc] init];

Overwritting NSObject init method

FILE: MyObject.m (APPEND)

// id is the common type of any NSObject
- (id) init
{
	// First init the super class and check everything went OK
        if (![super init]) return nil;
        // Set initial value
	m_value = 75.0f;
        // Return instance, self = this
	return self;
}

Custom initializer with arguments

FILE: MyObject.h (APPEND)

- (id) initWithString: (NSString*)string;

FILE: MyObject.m (APPEND)

- (id) init
{
	return [self initWithString: [[NSString alloc] initWithFormat:@"defaultTitle"]];
}

- (id) initWithString: (NSString *)string
{
	if (![super init]) return nil;
	m_value = 75.0f;

	// Use retain to keep the
	m_string = [string retain];
	return self;
}

Understanding Memory Management

1. MyObject *myObject = [MyObject alloc];
   //returns an instance with retainCounter = 1
2. [myObject retain];
   //make retainCounter++, call retain method if you want to keep the instance alive
3. [myObject release];
   // make retainCounter–, call release method when you have finished using the instance
4. When the retainCounter == 0, the dealloc method is called.

First thing required to avoid memory leaks is to implement dealloc method

FILE: MyObject.m (APPEND)

-(void) dealloc
{
   [m_string release];
   [super dealloc];
}

AutoRelease

This technique is NOT recommended for iPhone, because the memory resources of the phone aren’t very large and it’s a good idea deallocate instances as soon as they are not useful. But there are circumstances where there is no other option. If you want to overwrite NSObject method description, where you need to return an NSString, if you don’t want to keep a description string as an instance variable you have to return an autorelease string because you can’t release the return value before returning it.

- (NSString *) description
{
   NSString *result;
   result = [[NSString alloc] initWithFormat: @"Just an object to test];
   [result autorelease];
   // Alternative using class method
   // result = [NSString stringWithFormat:@"Just an object to test"];
   return result;
}

References

• C++ to Objective-C
• Objective C Static Class Level variables

You never know from where the inspiration will arrive. Doing some banking managements I took a look at one interesting Euribor Web Page and  I came across a nice charts with lots of options to be able to explore values along a wide time range. Doing some research I found that the flash chart used belongs to amCharts. This web offers  the use of a wide range of flash charts for free, including the stocks chart, the one that I was interested in.

So I downloaded the stocks chart, I read the documentation and explored the examples given by amcharts. After one or two hours I was playing with the stock chart filled with the temperatures values stored by my data logger, take a look at the result , more or less the same that you can see on top.

The stocks chart is a wonderful flash component. You don’t need to worry about almost nothing, just create a csv file with the date and the value you want to see per line. The stocks chart will do the hard job for you. Of course you can spend a lot of time exploring all settings but for the simple ones it won’t take too much. It gives you more or less the same behaviours of simple RRDTools graphs but being able to do some zooming interactively.

Exiten muchos libros, charlas y conferenciantes dedicados a tratar sobre el tema de cómo gestionar equipos, cómo mantenerlos motivados, etc… Después de leer unas cuantas, las siguientes tienen algo de dejavù. En mi opinión, esta conferencia de Ed Catmull se destaca de las demás en 3 aspectos.

1. Ed Catmull es el CTO de una empresa de renombre dentro del la producción de películas de animación y resulta que es un sector del que no abunda información de gestión de equipos.
2. En esta conferencia la mayoría de los consejos y recetas van acompañadas de una breve descripción sencilla de como ha llegado a esas conclusiones. Como en cualquier problema es muy importante definir las condiciones de contorno para poder aplicar la solución más adecuada. Muchas conferencias de este tipo no describen el contexto que llevó a las conclusiones que se exponen obviando gran parte del problema.
3. La conclusiones que aporta Ed Catmull sobre los cimientos de Pixar a la hora de gestionar sus equipos, bajo una apariencia de convencionalidad no lo son. De hecho, creo que aporta ideas muy modernas de gestión pero sin negar que implica asumir ciertos riesgos para que realmente fraguen. Vamos que nadie da duros a peseta. Quien no arriesga no gana.

Antes de seguir recomiendo la lectura Conferencia, pero si no tienes mucho tiempo aquí va mi resumen. 

A) Introducción

Mi intención en este resumen es destacar y sintetizar las ideas que más me han gustado, las relaciones entre ellas además de  alguna que otra opinion personal. Intentaré dentro de lo posible avalar las síntesis con recortes de la conferencia.

B) Fundamentos

“I don’t think our success is largely luck. Rather, I believe our adherence to a set of principles and practices for managing creative talent and risk is responsible”

Hasta aquí todo normal, no es la primera vez que oímos e incluso experimentamos que la gestión del equipo humano y los riesgos son la clave para llevar un proyecto empresarial a buen puerto. Sin embargo aquí se refiere al personal como el talento creativo, interesante. A lo largo de la conferencia Ed Catmull muestra su profunda convicción en que las personas con talento y creatividad marcan la diferencia entre el éxito y el fracaso.

“Some basic beliefs: Talent is rare. Management’s job is not to prevent risk but to build the capability to recover when failures occur. It must be safe to tell the truth. We must constantly challenge all of our assumptions and search for the flaws that could destroy our culture”

En mi opinión estas líneas,  al comienzo de la conferencia,  resumen las dos ideas principales de la charla:

• Talento y riesgo responsable van de la mano con el éxito.
• Potenciar el feedback interno real y mantener una búsqueda constante de los puntos flacos para mantenerse con los pies en la tierra.

C) “Talent is rare” & “Management’s job is not to prevent risk but to build the capability to recover when failures occur”

Durante la conferencia el talento y el riesgo tienen una relación simbiotica. En el siguiente párrafo es donde yo creo que Ed Catmull explica parte de esta relación.

“To act in this fashion, we as executives have to resist our natural tendency to avoid or minimize risks, which, of course, is much easier said than done.[...]. If you want to be original, you have to accept the uncertainty, even when it’s uncomfortable, and have the capability to recover when your organization takes a big risk and fails. What’s the key to being able to recover? Talented people! Contrary to what the studio head asserted at lunch that day, such people are not so easy to find”.

Por otro lado Catmull deja claro que el talento es poco común o infrecuente, y en esta línea plantea dos temáticas muy interesantes:

• Para encontrar talento hay que cultivarlo, es necesario crear el entorno para que se desarrolle y crezca.

  “What’s equally tough, of course, is getting talented people to work effectively with one another. That takes trust and respect, which we as managers can’t mandate; they must be earned over time. What we can do is construct an environment that nurtures trusting and respectful relationships and unleashes everyone’s creativity.”

  “If we get that right, the result is a vibrant community where talented people are loyal to one another and their collective work, everyone feels that they are part of something extraordinary, and their passion and accomplishments make the community a magnet for talented people coming out of schools or working at other places.[...] I believe that community matters.”

  “Our philosophy is: You get great creative people, you bet big on them, you give them enormous leeway and support, and you provide them with an environment in which they can get honest feedback from everyone”

• Una vez que se ha conseguido un equipo con talento hay que añadir la dificultadad de conseguir que sean capaces de trabajar de forma eficiente. En los siguientes recortes mientras Catmull describe las cualidades de un buen director, implicitamente está describiendo como permitir que el talento trabaje en equipo.

  “What does it take for a director to be a successful leader in this environment? Of course, our directors have to be masters at knowing how to tell a story that will translate into the medium of film. This means that they must have a unifying vision—one that will give coherence to the thousands of ideas that go into a movie—and they must be able to turn that vision into clear directives that the staff can implement.”“They must set people up for success by giving them all the information they need to do the job right without telling them how to do it.  Each person on a film should be given creative ownership of even the smallest task. ““Good directors not only possess strong analytical skills themselves but also can harness the analytical power and life experiences of their staff members. They are superb listeners and strive to understand the thinking behind every suggestion. They appreciate all contributions,regardless of where or from whom they originate, and use the best ones.”
  

D) “It must be safe to tell the truth” & “We must constantly challenge all of our assumptions and search for the flaws that could destroy our culture”

En mi opinión Catmull expone que la maquinaría de un estudio son las personas con su talento y con su creatividad al servicio de los objetivos del estudio y como toda maquinaría esta requiere un mantenimiento. Al contrario que las máquinas las personas evolucionamos, y de la misma manera tienen que evolucionar las labores de mantienimiento de la empresa. Cómo saber qué acciones de mantenimiento hacer en cada momento? Garantizando el feedback interno y manteniendo un cierto grado de paranoia, asumiendo que por muy bien que vayan las cosas siempre hay puntos flacos que encontrar y solucionar. Creo que los dos siguientes parrafos no tienen desperdicio, cremita pura.

“Observing the rise and fall of computer companies during my career has affected me deeply. Many companies put together a phenomenal group of people who produced great products. They had the best engineers, exposure to the needs of customers, access to changing technology, and experienced management. Yet many made decisions at the height of their powers that were stunningly wrongheaded, and they faded into irrelevance. How could really smart people completely miss something so crucial to their survival? I remember asking myself more than once: “If we are ever successful, will we be equally blind?”

Many of the people I knew in those companies that failed were not very introspective. When Pixar became an independent company, I vowed we would be different. I realized that it’s extremely difficult for an organization to analyze itself. It is uncomfortable and hard to be objective. Systematically fighting complacency and uncovering problems when your company is successful have got to be two of the toughest management challenges there are. Clear values, constant communication, routine postmortems, and the regular injection of outsiders who will challenge the status quo aren’t enough. Strong leadership is also essential—to make sure people don’t pay lip service to the values, tune out the communications, game the processes, and automatically discount newcomers’ observations and suggestions.”

E) Otras citas destacadas para la reflexión

• Sobre la política de comunicación interna.

  “Everyone must have the freedom to communicate with anyone.
  This means recognizing that the decision-making hierarchy and communication structure in organizations are two different things. Members of any department should be able to approach anyone in another department to solve problems without having to go through “proper” channels. It also means that managers need to learn that they don’t always have to be the first to know about something going on in their realm, and it’s OK to walk into a meeting and be surprised. The impulse to tightly control the process is understandable given the complex nature of moviemaking, but problems are almost by definition unforeseen. The most efficient way to deal with numerous problems is to trust people to work out the difficulties directly with each other without having to check for permission.”

  Francamente interesante. En este tema mi pregunta sería si está política de comunicación puede aplicarse a cualquier empresa o si solo es aplicable a empresas con una consolidación y madurez suficiente.

• Sobre la calidad

  “There has to be one quality bar for every film we produce”

  En esta cuestión no puedo estar más de acuerdo, creo que es importante cerrar un grado de calidad y satisfacción, y llevar a cabo los esfuerzos necesarios para conseguirlo. Y si no se está dispuesto a estos sacrificios es mejor parar y replantearse las cosas. Pero no se debería bajar y subir el listón según las cirscunstancias.

• Sobre la relación entre la tecnología y el arte

  “John coined a saying that captures this dynamic: “Technology inspires art, and art challenges the technology.””

  Esto ya es más una cita filosófica que puede quedar muy bien en la firma de un foro o en los emails :).

The third level in backup security and one of the most important is to be able to store backups in a place different than the production place, well known as Keep backups off-site. Currently taking advantage of free services like gmail, it´s much easier to fulfill this third level of backup security and to have all your backups available through an internet connection. Here I show a homemade script that does the following steps.

1. Compress your web server, database and svn repository
2. Encrypt compressed files with openssl
3. Send those files to a gmail account
4. Clean gmail account removing old backups

1. Shell script for backup compression and encriptation

a) Compression

This is the simple part. We will backup the SVN repository compressing the repository directory, and we will do the same for the web server, we will compress the www root directory. To backup the Mysql database we will first do a mysqldump and then we will compress the dump file. To configure de compression process we have to define the following variables.

• Backup Path: The path that will be compressed
• Archive Path:  The path where we want to store the last backups in your server.
• Backup History: How many backup days you want to keep in your server.

b) Encriptation

After having generated the backup files .tgz we will apply openssl encriptation so we can send this files through internet and be almost sure that no one will be able to access them.

c) Script code

#!/bin/bash
# backups

# command paths
TAR=/bin/tar
DATE=/bin/date
FIND=/usr/bin/find
ECHO=/bin/echo
MYSQLDUMP=/usr/bin/mysqldump
RM=/bin/rm
OPENSSL=/usr/bin/openssl
PYTHON=/usr/bin/python
SENDGMAIL=/etc/cron.daily/gmailSend.py
CLEANGMAIL=/etc/cron.daily/gmailCleanup.py

# script variables
DATECODE=`$DATE +%Y%m%d`
ARCHIVEDIR=<backupArchivePath>

BACKUPDIR1=<webServerPath>
ARCHIVE1=$ARCHIVEDIR/$DATECODE-wwwServerBackup.tgz
LOGFILE1=/root/backups/$DATECODE-wwwServerBackup.log
ERRORFILE1=/root/backups/$DATECODE-wwwServerBackup.err.log

BACKUPDIR2=<subversionPath>
ARCHIVE2=$ARCHIVEDIR/$DATECODE-svnBackup.tgz
LOGFILE2=/root/backups/$DATECODE-svnBackup.log
ERRORFILE2=/root/backups/$DATECODE-svnBackup.err.log

BACKUPDIR3=$ARCHIVEDIR/db.sql
ARCHIVE3=$ARCHIVEDIR/$DATECODE-dbBackup.tgz
LOGFILE3=/root/backups/$DATECODE-dbBackup.log
ERRORFILE3=/root/backups/$DATECODE-dbBackup.err.log


# Create log and error files if they don't exist and clean them
$ECHO > $LOGFILE1
$ECHO > $ERRORFILE1
$ECHO >> $LOGFILE1
$ECHO >> $ERRORFILE1

$ECHO > $LOGFILE2
$ECHO > $ERRORFILE2
$ECHO >> $LOGFILE2
$ECHO >> $ERRORFILE2

$ECHO > $LOGFILE3
$ECHO > $ERRORFILE3
$ECHO >> $LOGFILE3
$ECHO >> $ERRORFILE3

# Backup www
$TAR czvf $ARCHIVE1 $BACKUPDIR1 >> $LOGFILE1 2>> $ERRORFILE1
$OPENSSL enc -aes-256-cbc -e -in $ARCHIVE1 -out $ARCHIVE1.enc -pass pass:<password>
$RM $ARCHIVE1

# Backup svn repos
$TAR czvf $ARCHIVE2 $BACKUPDIR2 >> $LOGFILE2 2>> $ERRORFILE2
$OPENSSL enc -aes-256-cbc -e -in $ARCHIVE2 -out $ARCHIVE2.enc -pass pass:<password>
$RM $ARCHIVE2

# Backup database
$MYSQLDUMP -u<user> -p<password> --opt --all-databases > $BACKUPDIR3
$TAR czvf $ARCHIVE3 $BACKUPDIR3 >> $LOGFILE3 2>> $ERRORFILE3
$RM $BACKUPDIR3
$OPENSSL enc -aes-256-cbc -e -in $ARCHIVE3 -out $ARCHIVE3.enc -pass pass:<password>
$RM $ARCHIVE3

# Remove files more than 2 day old
$FIND $ARCHIVEDIR -type f -mtime +2 -exec rm -f {} \;

# Email files to gmail
$PYTHON $SENDGMAIL $ARCHIVE1.enc
$PYTHON $SENDGMAIL $ARCHIVE2.enc
$PYTHON $SENDGMAIL $ARCHIVE3.enc
$PYTHON $SENDGMAIL $ARCHIVE4.enc

# Clean gmail account moving all backup emails older than 60 days to the trash folder
$PYTHON $CLEANGMAIL

# Decript command
# $OPENSSL enc -aes-256-cbc -d -in $ARCHIVE4.enc -out $ARCHIVE4 -pass pass:<password>

2. Send the encripted backup files to your gmail account as Drafts

Using libgmail makes sending files to a gmail account terribly simple, the only problem you need to face is the attachment file size limitation of the gmail account, that during my develepment process was something around 20MB. To solve this issue, we use the split linux tool to cut big files in 19MB chuncks, and then we email each piece.

gmailSend.py

import sys, os
import libgmail
import glob

def sendFile(filename):
  accountName = <account name>
  accountPassw =  <account password>

  gmailAccount = libgmail.GmailAccount(accountName, accountPassw)
  try:
    gmailAccount.login()
  except libgmail.GmailLoginFailure:
    print "\nLogin failed. (Wrong username/password?)"
  else:
    print "Log in successful.\n"

    if gmailAccount.storeFile(filename, label='serverBackup'):
      print 'File stored successfully'
    else:
      print 'Could not store'

def main(argv):
  # Check file size < 19M
  if os.path.getsize(argv[1]) <= 19000000:
    sendFile(argv[1])
  else:
    # Call split -d -b 19000000 argv[1] argv[1]+'.'
    os.system('split -d -b 19000000 %s %s.'%(argv[1], argv[1]))

    # Call cat file.tgz.00 file.tgz.02 file.tgz.03 > file.tgz to compact splitted files

    # Go throug all files created from the split and send them
    filePieces = glob.glob('%s.*'%(argv[1]))
    for file in filePieces:
      sendFile(file)

if __name__ == '__main__':
  main(sys.argv)

3. Clean gmail account

After using the script during several months I ended using all the space of my gmail account so I had to do a manual clean up. To avoid this awful task I’ve added a final cleanup python script, responsible for moving all backup email drafts older than 60 days to the gmail trash folder. As gmail deletes all emails that have been in the trash more than 30 days, we will keep 3 months backup history.

gmailCleanup.py

import sys, os
import libgmail
import glob
import datetime

# This method parses the subject of the draft mail.
# It supposes that the subject of the email uses the backup script naming conventions
# Subject example: 'FSV_01 20081201-dbBackup.tgz.enc'

def ThreadSubject2Datetime(subject):
   items = subject.split(' ')
   if len(items) == 1:
      return None

   items = items[1].split('-')
   if len(items) == 1:
      return None

   date = items[0]
   return datetime.datetime(int(date[:4]), int(date[4:6]), int(date[6:8]))

# This script will move to the trash all draft emails older than 60 days
# As gmail deletes all email is the trash that have been there for 30 days,
# we will keep 3 months backup history
def main(argv):
   accountName = <account name>
   accountPassw = <account password>

   gmailAccount = libgmail.GmailAccount(accountName, accountPassw)
   try:
      gmailAccount.login()
   except libgmail.GmailLoginFailure:
      print "\nLogin failed. (Wrong username/password?)"
   else:
      folder = gmailAccount.getMessagesByFolder(libgmail.U_DRAFTS_SEARCH, allPages = True)
      for thread in folder:
         date = ThreadSubject2Datetime(thread.subject)
         if date:
            if date <= datetime.datetime.today() - datetime.timedelta(60):
            gmailAccount.trashThread(thread)

if __name__ == '__main__':
  main(sys.argv)

4. Known issues

• The gmailCleanup.py script supposes the gmail account is one created only for backup porposes.
• I’m sure that the shell script can be improved because I’m not an expert on bash scripting. You can use it as a start with script.
• I’m missing the configuration of the cron deamon to execute the shell script whenever you want because I think this is well documented in internet.
• Finally I think I should code all the process in python.

5.  Acknowledgments

Thanks to Javier Loureiro for the startup ideas around backups and gmail.

This is just a little tip for those who use python and work with COM automation components. If you are a windows user,  and you want to write python scripts to interact with Adobe Photoshop, Microsoft Excel, Microsoft Visual Studio the best way to do so is using the this application’s COM componts. But most of the times finding documentation this COM components registered in your Windows is tricky and difficult. Using a simple tool that is automatically installed with the pythonwin module, you can get wrap python classes for all interfaces and constants exported by a registered COM component. This usually helps a lot to find non documented methods, and even to make your python script more legible and clean.

Steps to get your wrap classes

1. Go to Start->Programs->Python->PythonWin

2. Menu Tools->COM MakePy utility->Explore and select the registered COM component you want to use.

3. The main window will show the path file where the python file has been generated

Use case with Adobe Photoshop CS3 Object Library

If you don’t want to use the wrap classes, you can access the name of the active document and the free memory available of an existing instance of Adobe Photoshop using the following code:

import win32com.client

cs = win32com.client.Dispatch("Photoshop.Application")
print cs.ActiveDocument.Name
print cs.FreeMemory

The other option is to use the PythonWin App to generate the wrap classes of Adobe Photoshop CS3 Object Library and then rename the odd python file name created by PythonWin with the something like this,  adobePhotoshop.py. Then place this file in a path where your python load modules, for example the same path where you have the file of your main script and then use the following code

import adobePhotoshop

acs = adobePhotoshop.Application()
print acs.ActiveDocument.Name
print acs.FreeMemory

There is not a big improvement compared with the firs option isn’t it?. The great advantage arrives when you use the wrap classes file with any python development environment like Eclipse+Pydev. During the development of your script you can use the Outline tool over the adobePhotoshop.py and explore the methods of any of the interfaces, for example the Application class and all its properties.

Tips to explore the wrap classes file, adobePhotoshop.py

1. Usually for each interface there is a wrap class with the same name, this is an empty class that is usually implemented in a class with the same name but started with underscore. For exampler, to explore the methods of the Application interface look for the implementationt in the class _Application.

2. To explore all data members of one interface explore the implementation of the _prop_map_get_ dictionary of the implementation class. For example, to explore the properties of the Application interface, look for the dictionary _prop_map_get_ of the class _Application.

Tip to find the entry point class

You will be wondering why betewen all those classes I know I have to invoke Application to access photoshop COM. Well it´s easy the entry point classes  inherits from CoClassBaseClass.

A great friend and coworker drew my south park caricature. It was a hand drawing so I scanned and get a dirty grey-scale image, not to nice. So to get something cleaner I realized that I will need to vectorize the image. To do so I was looking for some freeware and I found Inkscape. This open-source software is surprisingly great and the vectorizing tool is awesome for someone like me that was facing this problem for the first time. So in the following lines, I will briefly document how to vectorize a bitmap using Inkscape and the help of The Gimp.

Vectorizing process

1. Open the image in The Gimp and select the piece of the image you want to vectorize. Using Ctrl+C and then Ctrl+Shift+V you will create new image and save it (jpg or png will work well).
2. Open the Inkscape and Drag&Drop the the new image file into the main window of the Inkscape.
3. Select the image and click on menu Path->Trace Bitmap. A pop-up dialog will appear.
4. The Trace Bitmap dialog shows several methods to vectorize and a very useful Update button to see a preview of the vectorizing process result. Playing with the parameters for a while will show you all the possibilities.
5. When you arrive to a nice result in the preview, you can press OK and the final result will be showed in the main window ready to be edited.
6. Usually it’s a great idea to select the vectorized result and apply a simplification because the number of knots used for the paths during the vectorization process makes editing the strokes almost impossible. To do so click on menu Path->Simplify. Be careful because this algorithm sometimes simplifies too much, but it’s usually easy to solve this issues adding some points where the simplification was too aggressive.

Tips

1. If you have big black shapes, probably the vectorizer will create several white gaps. Increase the Suppress Speckles parameter within the Options tab to remove them.
2. Usually the Brightnees cutoff works pretty well, but when the edges of the shapes are well defined by colors use the Color Quantization

The main idea behind modelling using subdivision surfaces is to create simple geometry that after applying a smoothing algorithm like Catmull-Clark or Loop it finally gets its smoothed and final shape. This way you model the low resolution mesh and you get the higher resolution meshes applying different levels of this smoothing modifiers.

The main problem is that this smoothing algorithms will smooth at all cost and you sometime want to keep several edges chamfered but hard. One way to do this is creating bound edges around the edges you want to be hard.

I’m using 3dsmax as the modeling software and to start playing with this I found the exercise of keeping a box like a box after applying a TurboSmooth a great way of understanding the behavior of the smoothing algorithms

Another a bit more complex example. This time we will create a smoothed gear. Here I show you one strategy

Thanks to Ramón

One interesting technique to model real things, is to use pictures of this real things as a reference and place them in our modelling software so we can do the blocking of the model based on that visual information. Here I will describe step by step how to do it using 3dsmax. Thanks to Ramón for all the help.

1. Make 3 photographs from Top, Front and Left sides. Use tripod and avoid as much as posible the perspective deformation




2. Use The GIMP to crop, cut and paste each of the photos in one big picture, aligning each photo and making them fit.



3. Use guides to match the sides of each view and crop one image per view
4. Create a square size image (512×512) and paste the cropped images in the center of the square image, then save it. The square size is important for the 3dsmax viewports to show them properly.
5. Finally you have 3 square size images

Configuring 3dsmax vewports

1. Press Alt+B on each viewport
2. Elegir el fichero de la imagen y después rellenar las opciones como se muestra en la pantalla



3. Repetir con cada viewport hasta conseguir la siguiente imagen

Tuve la suerte de poder asistir a la edición de este año de MundosDigitales, festival de la industria del 3D que se celebra anualmente en La Coruña y que reune a personas de la mayoría de los estudios de animación nacionales y parte de Europa. Es un encuentro muy agradable donde asistir a conferencias sobre este mundillo y hacer amigos del sector.

Para no olvidarme de las conferencias que considero que más me han gustado, voy a llevar a cabo unos cuantos post en que describiré varias ponencias de Mundos Digitales 08 de forma desenfadada y con bastantes aportaciones personales (quién avisa no es traidor),

[Post in spanish because I feel more comfortable using my native language and I don´t have too much time to translate this in english. Content just for spaniards sorry.]

EL CAMBIANTE MUNDO DEL PIPELINE EN EL CINE
Sebastian “Beowulf carnosico” Sylwan

Y empezaré con una conferencia que sin ser muy técnica me llegó (Qué fuerte!) . Así en breve, este gurú del cine y los efectos nos vino a contar que la industria del 3D está en plena etapa de industralización, justo en ese momento en que se pasa del producto artesanal a la fabricación industrial. De producciones pequeñas en número y de calidad gracias a la dedicación, al mimo y tiempo empleado, a las producciones de grandes tiradas donde la eficiencia y el rendimiento de fabricación permitirán que los contenidos 3D sean más asequibles y sofisticados. Todo esto aderezado con datos, gráficas escaladas (homenaje al Sr.Loureiro) y más datos y más graficas y tal. Que si su predicción se cumple no habrá peli sin VFX y además serán más baratos y se produciran como churros.

Pero a mi lo que me molo fueron dos grandes conceptos: LA SANTISIMA TRINIDAD y LA PIRAMIDE DEL VALOR

LA SANTISIMA TRINIDAD

Sebastian no se refirió a este tema ni con este título ni éxactamente con estos nombres, me he permitido la licencia de rebautizarlos para darles un poco más de empaque. En resumen un recordatorio por parte del Sr. Sylwan, de los ingredientes principales para cualquier producción con pretensiones: Poderío Tecnológico, Talento Artístico y Visión Comercial.

LA PIRAMIDE DEL VALOR

Y ahondando en la misma temática pero centrándose en el poder tecnológico, Beowulf nos mostró más conceptos interesantes usando la pirámide del valooorrrr. Aquí podemos ver una propuesta de los cimientos en los que asentar un estudio y lo que deberían aportar a la producción si se usan correctamente. De esta manera:

• El pipeline si se está bien diseñando debería aportar estabilidad a la producción
• El software si se elige bien y se usa correctamente debería aportar eficiencia a la producción
• La fontanería que era como se refería Sebastian a los desarrollos a media internos, deberían facilitar la integración del software en el pipeline de la producción
• Y por último las diferencias con los competidores de una producción deberían siempre estar relacionadas con aspectos innovadores.

En principio ninguno de estos gráficos ni los conceptos que muestran son la pera limonera, pero muchas veces ponerle nombre a las cosas y monstrarlos en una imagen ayuda integrarlos más facilmente y los hace más poderosos. Además son un rato pintones.

Incredible, people from Playskool knows what I need, they have already released the new MrPotato Indiana Jones, with integrated sound in the hat. So I can get rid of the useless Indiana Jones soundtrack emitter and replace it with my voice synthetizer :D. Now I only need some spare time.

I agree it´s not very friendly, it´s a kind of ugly, but it´s a MrPotato c´mon and if you press on the hat you will get some music, isn´t it cute?. During this summer holidays I need to be working on that defenitely. MrPotato v.3 is about to come. Muhahahaha