Marco Bonifazi

NINE 1.1 released!

2011-04-16T03:16:00.008+02:00

Here is my first public and very simple Android application!

https://market.android.com/details?id=bonifazi.nine

Nine 1.1

Android/Java: Download a file from an URL to sdcard updating a ProgressBar/ProgressDialog

2010-10-21T17:37:00.003+02:00

Here is a simple class for download management with ProgressDialog realtime updating

String path_to_local_file = "/mnt/sdcard/marco_bonifazi.txt";
String url = "http://www.bonifazi.eu/marco_bonifazi.txt";

DownloadManager downloader = new DownloadManager(this, url, path_to_local_file, dialog);

boolean res = downloader.checkInternetConnection();

if (!res ) {
    downloader.alertMissingConnection("No internet connections available");
} else {
    res = downloader.download();

    if (!res ) {
        downloader.alertMissingConnection("URL not available");
    } 
}


class DownloadManager extends AsyncTask{

    private URL url;
    private String filename;
    private ProgressDialog dialog;
    private URLConnection ucon;
    private Context context;
    
    public DownloadManager(Context context, String file_url, String filename, ProgressDialog dialog)  {
        this.context = context;
        this.dialog = dialog;

        try {
            this.url = new URL(file_url);
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
        this.filename = filename;
    }
    
    public boolean checkInternetConnection() {
        ConnectivityManager cm = (ConnectivityManager) this.context.getSystemService(Context.CONNECTIVITY_SERVICE);
        if (cm.getActiveNetworkInfo() == null){
            return false;
        } else {
            return true;
        }
    }
    
    public void alertMissingConnection(String message) {
        AlertDialog.Builder builder = new AlertDialog.Builder(this.context);
        builder.setMessage(message)
        .setCancelable(false)
        .setPositiveButton("Ok", null);
        AlertDialog alert = builder.create();
        alert.show();
        return;
    }

    boolean download() {
        try {
            this.ucon = url.openConnection();
            this.ucon.connect();
            this.execute("");
            return true;
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
    }

    @Override
    protected void onPreExecute() {
        this.dialog.setTitle("Downloading...");
        this.dialog.setIndeterminate(false);
        this.dialog.show();
    }
    @Override
    protected void onPostExecute(Integer result) {
        this.dialog.hide();
        this.alertMissingConnection("Download finished");
    }

    @Override
    public void onProgressUpdate(Integer... args) {
        this.dialog.setProgress(args[0].intValue());
    }

    @Override
    protected Integer doInBackground(String... params) {
        try {
            int n_bytes_packet = 0;
            int current_bytes_read = 0;
            int percent = 0;
            int n_total_bytes = this.ucon.getContentLength();

            BufferedInputStream ios = new BufferedInputStream(this.url.openStream());
            FileOutputStream fos = new FileOutputStream(new File(this.filename));
            byte data[] = new byte[256];

            while ((n_bytes_packet = ios.read(data)) != -1) {
                current_bytes_read += n_bytes_packet;
                percent =  current_bytes_read * 100 / n_total_bytes;
                fos.write(data, 0, n_bytes_packet);
                publishProgress(percent);
            }
            fos.flush();
            fos.close();
            ios.close();
            Log.d("fileManager", "Ok");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

OpenCV in Android, setup an image from a Bitmap pixel buffer, converting

2010-10-08T19:04:00.002+02:00

JNIEXPORT void JNICALL Java_com_convert(JNIEnv *env,
                                        jobject thiz,
                                        jobject bitmap) {
    const int width = 2592; // You can also get them through JNI
    const int height = 1952;
    IplImage* image = cvCreateImage(cvSize(width, height), IPL_DEPTH_8U, 2);
    cvInitImageHeader(image,
                      cvSize(width, height),
                      IPL_DEPTH_8U, 2, IPL_ORIGIN_BL, 4);
    int *cv_data;
    AndroidBitmap_lockPixels(env, bitmap, (void**)&cv_data);
    cvSetData(image, cv_data, width * 2);
    IplImage* grey_img = cvCreateImage(cvGetSize(image), IPL_DEPTH_8U, 1);
    cvCvtColor(image, grey_img, CV_BGR5652GRAY);
    cvSetData(image, NULL, 0);


    image = grey_img;
    DO_WHAT_YOU_WANT_WITH_YOUR_IMAGE(&image);


    AndroidBitmap_unlockPixels(env, bitmap);
}

Releasing Android applications without going through the Market

2010-10-04T15:23:00.009+02:00

It is assumed that the development framework and platform used is Eclipse, with the official Android platform plugins. It is also assumed that your are using Linux, because it's what I'm doing.

Update the software version in your logging mechanism;
update the software version in the AndroidManifest.xml file, it has to be coherent with the version of the previous step;
give a Project->Clean just for the sake of being sure that all is fine;
remember to update the “linking” of C/C++ libraries in the Java/Android platform (give a “refresh” with “F5” in the jni/lib directory, copy and paste jni/lib also into the root path of the project);
export the package using Eclipse (with the official Android plugin) using this package name convention: YOUR_PROJECT_NAME_unaligned.apk.

The Eclipse exporter will require for a key to be created, with security passwords: it's an operation related to certificates which is very important if the software is to be released to the official Android market;

align the software:

zipalign -v 4 YOUR_PROJECT_NAME_unaligned.apk YOUR_PROJECT_NAME.apk
It's an operation required by Android applications just before you can use them into the Android mobile phones.

Installation procedures

Installing the application into the Android mobile phones WITHOUT passing through the Market is an easy task.

Cleanup previous releases of the software

For the sake of perfection it's better that you cleanup every kind of previous data/files you could have left related to your application: previous releases, directories created, personal configurations, etc.
Two ways to do that:

using a file manager/explorer which you will find easily on the Android Market and delete the files directly from the mobile phone;
mounting the file system of your mobile phone onto the Linux development machine and give a

rm -r DIRECTORY_TO_BE_REMOVED

Upload the application package

You have just to upload YOUR_PROJECT_NAME.apk file into a directory in the mobile phone.
You can do that using two different methods:

using the DDMS perspective in the Eclipse framework (“Push a file onto the device”);
mounting the file system of your mobile phone as usb key and copy the project file using your Linux shell.

Install your application

Once you've got you file into the file system of the mobile phone, you can use whatever Application Installer or File Explorer you will find in the Android Market, locate your file and installing it.

Compile OpenCV for Android on Linux or Mac, high level hints

2010-09-11T02:33:00.000+02:00

Android's market share is being the most growing among the Operating Systems for smartphones.

OpenCV is (from Wikipedia) a computer vision library originally developed by Intel. It is free for use under the open source BSD license. The library is cross-platform. It focuses mainly on real-time image processing.

http://sourceforge.net/projects/opencvlibrary/

The initial revision of OpenCV was in C, with the latest revision C++ has been introduced in many sections of the code.

Android NDK is the developer toolkit to plug C and C++ code into an Android application, whose default implementation language is Java (which works upon the Dalvik virtual machine, created for Android).

It must be used together with the Android SDK, which is the development framework for you Android/Java applications.

Your C++ code should be used as a library which communicates (through JNI, Java Native Interface) to the Java layer.

The main problem in order to get OpenCV compiling on Android relies on the fact that the Android NDK doesn't provide a full standard C++ ("Minimal set of headers for C++ support"), for example exceptions can't be used in the Android C++. It's probably a way to discourage people from using C++ as a native language for the Android applications. Or maybe it's because Google doesn't like C++ exceptions, especially in an embedded system context.

Luckily, there are some guys who got full C++ working for Android, you just have to download it and compile.

To use that, you have to download a tweaked C++ Android NDK, from Crystax site:

http://www.crystax.net/android/ndk-r4.php

What you finally need is also OpenCV, ported to Android

http://billmccord.github.com/OpenCV-Android/

Now you have to install the "Crystax" Android NDK as it was the official one, following the related guide:

http://developer.android.com/sdk/ndk/index.html

You have to compile OpenCV with the Android NDK, considering it as a NDK application (check the samples in the ndk directory). The OpenCV for Android zip already contains the files/scripts to be compiled in that way.

If you want to embed your custom C++ code in it, you can easily do that, modifying the Android.mk file and restructuring the hierarchy of the directories in your project.

In my case, I simply added a subdirectory to the OpenCV one, moved there all my source code, and compiled it together with OpenCV.

Final note: remember

APP_ABI := armeabi armeabi-v7a

in the file Applications.mk if your mobile cpu supports it; your application will run much faster!

Sapthesis, a LaTeX class for your theses

2010-09-03T22:34:00.001+02:00

sapthesis.cls.
A class for the typesetting of the Ph.D., master and bachelor theses of the "Sapienza - University of Rome".
http://biccari.altervista.org/c/informatica/latex/sapthesis.php

Replace a string in a list of files

2010-08-27T09:44:00.002+02:00

#!/usr/bin/python
import fileinput, glob, string, sys, os
from os.path import join
# replace a string in multiple files
#filesearch.py


if len(sys.argv) < 2:
    print "usage: %s search_text replace_text directory" % os.path.basename(sys.argv[0])
    sys.exit(0)


stext = sys.argv[1]
rtext = sys.argv[2]
if len(sys.argv) ==4:
    path = join(sys.argv[3],"*")
else:
    path = "*"


print "finding: " + stext + " replacing with: " + rtext + " in: " + path


files = [filename for filename in os.listdir(".") if not os.path.isdir(filename) and (filename[-4:] == ".cpp" or filename[-2:] == ".h")  ]#glob.glob(path)
print files
for line in fileinput.input(files,inplace=1):
  lineno = 0
  lineno = string.find(line, stext)
  if lineno >0:
        line =line.replace(stext, rtext)

Create a series of md5 digests from a file

2010-08-27T09:39:00.004+02:00

You can create md5 digests from a file, each line in the file is a different digest.
www.bonifazi.eu/appunti/createmd5.py

#!/usr/bin/python
import hashlib
import sys


f = open("my_lines.txt", "r")


for line in f.readlines():
    line = line.strip()


    m = hashlib.md5()
    m.update(line)
    print(line + ":::" + m.hexdigest())




f.close()

Discover the largest product of five consecutive digits in the 1000-digit number.

2010-08-23T23:55:00.001+02:00

The code is a bit awful and not optimized... Python is really easier to work with in order to solve these kinds of algos!

product.cpp
string.txt

g++ -o product product.cpp

Prime numbers generator

2010-08-23T00:05:00.000+02:00

It's just a first C++ implementation for the Euler Project

primes.cpp
primes.h

In order to compile:
g++ -o prime primes.cpp

Python, PyGtk, PyOpenGL, PyWin32 all in one installer

2010-08-21T03:34:00.000+02:00

After Gtk+ Installer, I realized also a PyGtk all in one installer, for Python 2.6 http://www.python.org/download/windows/

You can download it from here:

pygtk_windows_installer.exe

It is simply an assembling of all the different installers I previously downloaded (which are executed step by step), and you can choose.

I realized this installer using EclipseNSIS and compiling the script generated by NSIS.

Then, the script I created and that you can compile and modify using NSIS is the following:

pygtk_windows_installer.nsi

Gtk all in one installer

pygobject-2.20.0.win32-py2.6.exe
pycairo-1.8.6.win32-py2.6.exe
pygtk-2.16.0+glade.win32-py2.6.exe
PyOpenGL-3.0.1.zip
pywin32-214.win32-py2.6.exe

I'll try to keep update this installer.

Gtk+ 2.20, Glade 3.7.1, GtkGlExt 1.2.0 all in one Windows installer

2010-08-21T03:28:00.001+02:00

I created an all in one Windows installer,
for using Gtk+ libraries,
also with Glade 3.7.1 (GUI visual creation) and
GtkGlExt (OpenGl embedded in a GtkDrawingArea).

You can download the Gtk+, Glade, GtkGlExt global installer from this links:
Gtk+, Glade, GtkGlext all in one Windows installer

The installer simply copies the files into a Gtk directory, updating PATH environment variable.

Optionally, you can also get the different parts of the dlls which form the previous installer from the following links:
Gtk+ for Windows
Glade 3.7.1 zip for Windows
GtkGlExt installer for Windows

All the libraries are updated to the last version of today, and they seem to be perfectly useful (my project works very well).
I'll try to mantain here the most updated files.

You can view the licenses from those links.

The installer was created using
NSIS (Nullsoft Scriptable Install System
with its Eclipse plugin

The script file generated and compiled to create the installer is the following
setup_gtk.nsi
which uses this one as well
EnvVarUpdate.7z
(have a look at this page for path settings: /Environmental_Variables

Updating this installer is easy!
It is simple to maintain by everybody.

You must only install NSIS,
take the Windows binaries of the different tools from the official links,
put them in c:\program files\GTK directory,
compile setup_gtk.nsi file here aboveI updated.

Updated to the date of this post with the latest libraries:

Glade 3.7.1!
Libglade 2.6.4
GLib 2.24.0
GTK+ 2.20.0
Pango 1.28.0
ATK 1.30.0
Cairo 1.8.10

OpenCL links

2010-07-15T22:59:00.001+02:00

http://en.wikipedia.org/wiki/OpenCL
Ibm: http://www.alphaworks.ibm.com/tech/opencl/download
Amd: http://developer.amd.com/zones/OpenCLZone/Pages/default.aspx
NVidia: http://www.nvidia.com/object/cuda_opencl_new.html
Khronos Group: http://www.khronos.org/opencl/

Code optimization, C++

2010-07-15T15:40:00.002+02:00

http://www.agner.org/optimize/

OProfile + Gprof2Dot commands in order to get wonderful profiling graphs

2010-06-15T17:16:00.003+02:00

opcontrol --reset

opcontrol --start
[run your application]

opcontrol --shutdown

opreport -cg ./my_test /usr/lib/my_libraries | python gprof2dot.py -f oprofile | dot -Tpng -o output.png

http://oprofile.sourceforge.net/news/

http://code.google.com/p/jrfonseca/wiki/Gprof2Dot

http://gprof2dot.jrfonseca.googlecode.com/hg/gprof2dot.py

Check the memory heap usage and its maximum (peak)

2010-06-15T14:41:00.001+02:00

It's very useful to know the memory heap usage of an application.

The Massif tool of Valgrind framework gives you back some screenshots (you can tweak their frequency quite easily) related to the amount of the memory heap used at that moment.

It is very useful when you have limited memory per application/process.

http://valgrind.org/docs/manual/ms-manual.html

Here are the commands:

valgrind --tool=massif --detailed-freq=1 ./test_application

ms_print massif.out.xxx > log.txt

2008 - mpydxf: Marco's Python Dxf

2009-12-27T16:59:00.005+01:00

Python Library for creating Data Exchange Format (Dxf) files for AutoCad drawings, with many primitives
MPyDxf Google Code

2007 - Orthogonal graph drawings

2009-12-27T16:59:00.001+01:00

Application for creating segments, arcs, knots, grids and minimize orthogonal graph drawings, area compactation
Mago Google Code

2006 - Cryptography

2009-12-27T16:58:00.003+01:00

Theory of prime numbers, RSA: course project at university

2006 - Minimal application for degrees conversion

2009-12-27T16:58:00.001+01:00

PyGtk, Glade, Python used together for converting temperature degrees representations: Celsius, Fahreneit, Reaumur, Kelvin

2005 - Computer Networks

2009-12-27T16:57:00.001+01:00

Analysis of the American Airlines website: traceroute, whois, sniffing, ping, autonomous system - Simulation of a 15 Autonomous Systems network, 25 routers with Netkit, test of BGP dampening effect

2005 - Computer graphics

2009-12-27T16:56:00.003+01:00

OpenGL: a simple room and the implementation of convex hull algorithm, robot and table, traversal algorithm, texture, lighting

2005 - Databases

2009-12-27T16:56:00.001+01:00

Testing queries against DB2 tables, from OLTP to OLAP: feeding of Datamarts, DB2 datawarehouse module

2005 - Concurrent programming

2009-12-27T16:55:00.003+01:00

Mini webserver in Linux C, handling of fixed pool of thread, synchonization of threads with condition variables.

2005 - Digital processing

2009-12-27T16:55:00.001+01:00

Created PID discrete controller, in Matlab

2004 - Bachelor's degree, Thesis

2009-12-27T16:54:00.001+01:00

Introduction to the element finite methods, examples in Femlab e Catia, comparison

2004 - Distributed systems

2009-12-27T16:52:00.000+01:00

Web application for secretary's office: Java, JSP, servlet, Torque, Postgres, MVC

Glade 3.6.7 for Windows, installer

2009-11-01T12:45:00.000+01:00

I've compiled Glade 3.6.7 for Windows.

Also the new libglade 2.6.4 has been compiled for Windows and included in the package.

You simply have to unzip the following file into Gtk directory:
glade3.zip
I've created an installer, but it you have to remember that Glade works only with GTK libraries properly installed.
Glade-3.6.7_setup.exe

For compiling I've used the guide in this link:
http://gpz500.wordpress.com/2008/04/18/glade3-per-windows/

If you need an all in one installer you can use the Gtk one of mine, I've update including Glade:
GTK-2.16.5 installer

Simple C Gtk Project in DevCpp

2008-03-24T11:28:00.000+01:00

I tried to compile a simple C Gtk Project in DevCpp.
There are many things to do, especially about Include dirs, Lib dirs.
I updated also a new Gtk installer, because I insert new include files that there weren't before and that created errors in compiling.

The fastest way to explain, I think, is to upload the Simple_gtk_project.dev with the source simple_gtk_main.c
This file was used on my Italian Windows XP pc, then it has wrong links that you must substitute with yours.
Then you must change, in .dev, file all "C:\Programmi\Gtk" with your Gtk home dir (for example "C:\Program files\Gtk").

If you want to do by yourself I can suggest some hints:

you must enter in "Project Options" menu

in "Parameters" tab, you must set Compiler and Linker options:

in Compiler area insert "-mms-bitfields"

in Linker area you must insert all libraries (dll) which are in your "GTK\bin" dir:
-lm
-lbzip2
-lcharset
-lfreetype6
-lglut32
-liconv
-lintl
-ljpeg62
-lart_lgpl_2-2
-latk-1.0-0
-lcairo-2
-lcroco-0.6-3
-lexpat
-lfontconfig-1
-lfreetype-6
-lgdk-win32-2.0-0
-lgdkglext-win32-1.0-0
-lgdk_pixbuf-2.0-0
-lgio-2.0-0
-lglade-2.0-0
-lgladeui-1-7
-lglib-2.0-0
-lgmodule-2.0-0
-lgobject-2.0-0
-lgsf-1-114
-lgsf-win32-1-114
-lgthread-2.0-0
-lgtk-win32-2.0-0
-lgtkglext-win32-1.0-0
-lpango-1.0-0
-lpangocairo-1.0-0
-lpangoft2-1.0-0
-lpangowin32-1.0-0
-lpng12
-lpng13
-ltiff3
-lxml2
-lzlib1
-l_gl2ps_sw

in Files/Dirs tab you must set:
in Library dirs subtab: your "GTK\bin" dir

In my case
c:\Programmi\Gtk\bin

in Include dirs subtab you must set all the subdirs in "GTK\include"your "GTK\include" dir

In my case they are:
c:\Programmi\Gtk\include\gtk-2.0;
c:\Programmi\Gtk\include\cairo;
c:\Programmi\Gtk\include\glib-2.0;
c:\Programmi\Gtk\include\atk-1.0;
c:\Programmi\Gtk\include\libxml;
c:\Programmi\Gtk\include\pango-1.0;
c:\Programmi\Gtk\include\libgladeui-10

Nothing else, it seems to compile and execute fine.

The exe file I generated is here:

Simple_gtk_project.exe

Stupid file list

2008-03-18T11:50:00.000+01:00

Creates a dir.txt with the content list (files and dirs) of the current dir.

file_list.py

Distro Linux Time Line

2007-05-19T03:23:00.000+02:00

Distro Linux Time Line

PyGtkGlExt, a simple OpenGl box in a PyGtk Window

2007-05-02T22:47:00.000+02:00

It is an example of a Python application with a Gtk GUI with an embedded OpenGl box.
This fusion is allowed thanks to GtkGlExt library and all Python wrappers of these ones.

GUI and run application Draw.py
Glade file first_example.glade

To draw the OpenGl area is fundamental to remember the connection of expose/realize/configure events (without them I had serious troubles).

Vettori in C

2007-04-21T16:54:00.002+02:00

Gruppo di posizioni di memoria, stesso nome, stesso tipo di dato.
Dichiarazione:
int array[5]
Dichiarazione e inizializzazione:
int array[5] = { 1, 2, 3, 4, 5}
Dichiarazione mancante ma inizializzazione:
int array[] = { 1, 2, 3, 4, 5}
Azzeramento automatico degli elementi del vettore quando ci sono meno inizializzatori della lunghezza dell'array (ma ne serve almeno uno).

int array[5] = {1,2,3}; corrisponde a
int array[5] = {1, 2, 3, 0, 0};

Le stringhe sono array di caratteri:
char* prova = "ciao"; corrisponde a
const char* prova = "ciao", che corrisponde a
const char prova[] = {'c', 'i', 'a', 'o', '\0'}
dove '\0' e' il carattere che termina le stringhe

All'interno di funzioni, se l'array e' "static" allora viene automaticamente inizializzato dal compilatore

static int a[5]; corrisponde a int a[5] = {0,0,0,0,0} ma solo la prima volta che la funzione viene chiamata (successivamente conserva i valori precedenti, static serve proprio a svincolare la "localita'" della variabile).

Passaggio di vettori a funzioni.

Passaggio vettori e' per riferimento, in pratica il nome del vettore e' l'indirizzo del primo elemento

char array[4] ="ciao";
passo(array);
corrisponde a passare
&array[0] oppure
&array

modifica_vettore(mio_array, lunghezza_mio_array);
...
void modifica_vettore(int array[], int lunghezza_array);

Passaggio e' per riferimento (il vettore e' modificabile).
Per rendere il vettore non modificabile la funzione deve essere definita avendo parametro del vettore con const

void modifica_vettore(const int array[], int lunghezza_array);

Array con permanenza in memoria statica e automatica

array.c

Script vari Gentoo/Linux

2007-03-31T21:10:00.000+02:00

HP Pavilion 8051dv, Xpress 200, Amd Turion64
XOrg 7.2
Ati-drivers 8.35
Mesa 6.5.2
Kernel 2.6.19, gentoo-sources

Xgl

Xgl -fullscreen :1 -audit 0 -ac -accel glx:pbuffer -accel xv:pbuffer & sleep 4
LD_PRELOAD=/usr/lib/opengl/ati/lib/libGL.so LD_LIBRARY_PATH=/usr/lib/opengl/ati/lib/ DISPLAY=:1 beryl-manager
DISPLAY=:1 heliodor &

Problema Ethernet a soli 10 Mbit

ethtool -s eth0 speed 10 duplex full autoneg on

xorg.conf

fstab

grub.conf

make.conf

Kernel
config

GktGlExt 1.2.0 Windows

2007-03-31T20:50:00.000+02:00

Binari GtkGlExt compilati per Windows32

gtkglext-win32-1.2.0.exe

Java plugin in Firefox su Gentoo a 64 bit

2007-03-05T17:15:00.000+01:00

Non esiste un Java Plugin per Firefox a 64 bit.
Pertanto occorre installarsi Firefox a 32 bit (in un Gentoo a 64 bit quindi si fa "emerge mozilla-firefox-bin").

Poi occorre prendersi un JRE a 32 bit e installarselo da qualche parte (supponiamo /opt/jre-1.5.11).

Si va nella directory dei plugin di Firefox: /opt/firefox/plugins/.

Si fa in link simbolico
ln -s /opt/jre1.5.0_11/plugin/i386/ns7/libjavaplugin_oji.so ./

Casi d'uso (use cases)

2007-01-17T17:12:00.000+01:00

Collezione di storie delle interazioni col sistema per incontrare gli obiettivi delle parti interessate.

Attore: caratterizzazione di un modo di comportarsi
Scenario: sequenza di azioni e interazioni attori e sistema.

Uno scenario e' un'istanza di un caso d'uso, una storia, una sequenza di azioni che produce un risultato osservabile ad uno o piu' attori.
I casi d'uso quindi sono formati da scenari di successo e di fallimento, vanno considerati nel pensare alla maniera, al modo in cui il sistema cerca adempiere agli obiettivi.

I casi d'uso sono requisiti (spesso quelli funzionali).

Non scendere in dettagli, pensare solo al COSA, non al COME (analisi contro progettazione).

Tipi di casi d'uso:

Brevi, storia scritta in un paragrafo lungo.
Informali, diversi paragrafi, eventuali casi d'uso alternativi.
Completi, struttura formata da

Prefazione
Parti interessate e relativa lista di interessi
Precondizioni e postcondizioni.
Scenario di successo (happy scenario), senza condizioni formato da interazioni tra attori, validazione del sistema o cambiamento dello stato del sistema.
Scenari alternativi, estensioni, formate dalla condizione e dalla gestione dello scenario. C'e' eventuale ritorno a scenario di successo. Scenari alternativi complessi potrebbero essere un altro caso d'uso
Requisiti speciali (non funzionali, ad es. "tecnologici")
Lista variabilita' tecnologiche e dati (eventuali vincoli a priori)

Livello di dettaglio: riferirsi principalmente a Elementary Business Process

Task di una persona in un luogo ad un certo tempo in risposta ad un evento che aggiunge un valore misurabile lasciando i dati in stato consistente.
Cosa fare.
Quali sono gli obiettivi. Quale e' l'obiettivo padre, ricorsione.

Sottoobiettivi vanno considerati come caso d'uso quando sono precondizioni di piu' scenari di casi d'uso.

Dominio del sistema
Attori primari e obiettivi: trovare attori primari (tra cui i "sistemi", il computer)

Analisi e progettazione

2007-01-17T15:03:00.000+01:00

Analisi: capire problema e requisiti
Progetto: soddisfare requisiti, soluzione concettuale, non implementazione

Fare le cose giuste (analisi) e farle correttamente (progetto).

Analisi a oggetti: trovare e descrivere gli oggetti.
Progetto a oggetti: capire come oggetti software collaborano per soddisfare i requisiti.

UML:

linguaggio per specificare, visualizzare, costruire, documentare artefatti di sistemi software.

C, OpenGl: glCallList, Quads

2007-01-15T01:01:00.000+01:00

gl2.c.html

C - OpenGl, create a stupid Window

2007-01-06T12:23:00.000+01:00

This is a segment in an example OpenGl window.
It is written to remember all the steps to create a window and give an Ortho perspective, and managing coordinates system.

gl.c.html

To compile in Linux:

cc -o gl gl.c -lglut -lGL -lGLU -lm -L/usr/X11R6/lib

In WIndows it is important to compile and link with math, gl, glu, glut library.
For example in DevC++ we must insert -lm, -lglu, -lgl, -lglut in linker options.

PyInstaller: creare un eseguibile per Windows (ma il procedimento dovrebbe esser simile per altri Sistemi Operativi)

2006-12-13T10:42:00.000+01:00

Sito ufficiale (nuovo) di
PyInstaller

PyInstaller trasforma programmi scritti in Python in eseguibili a se stanti, la cui esecuzione diventa indipendente dall'interprete Python.

La mia applicazione prevede uso di PyGtk.

Passi da compiere:

Scompattare lo zip scaricabile dal sito in una directory a piacere, da console ("cmd.exe") mettere python.exe nel PATH di Windows ("SET PATH=$PATH;C:\Python25\")
Solo per comodita' conviene spostare la cartella appena scompattata nella cartella genitore del nostro progetto (ad es. se il progetto e' in C:\Padre\Progetto, conviene che PyInstaller sia nella cartella C:\Padre\PyInstaller)
Creare un file di tipo .spec, che "imposta" la configurazione del progetto, al seguente modo:
python Makespec.py -w ..\Progetto\programma.py

Cosi' facendo verra' creata nella directory di PyInstaller una directory "programma" con all'interno altre directory e il file spec appena creato.
Per creare infine l'eseguibile:Python Build.py Progetto\programma.spec Verra' quindi creata la directory "distProgramma" in cui all'interno si avra' il file exe con tutti i dll a cui si appoggia eventualmente il nostro programma Python.

Makefile di esempio

2006-04-27T16:48:00.000+02:00

OBJS=params_main.o params_print.o
EXE=params
$(EXE): $(OBJS)
$(CC) -o $@ $^
@echo "Obiettivo "$@ # $@ Rappresenta l'obiettivo (in questo caso params)
@echo "Dipendenze "$^ # $^ e' una macro che rappresenta tutte le dipendenze dell'obiettivo, in questo caso params_main.o eparams_print.o
@echo "Dipendenze recenti " $? # $? Rappresenta l'elenco di quelle dipendenze che sono state cambiate recentemente (calcolate automaticamente)
@echo "boh "$< # $<>

Linux Scripting: CUT

2006-04-26T00:44:00.000+02:00

cat /etc/passwd |cut -d ':' -f1|tr "\n" ","

Mette la lista utenti in una lista con virgole.

Creare gl2ps in Python con Swig (in Windows)

2006-03-30T15:51:00.000+02:00

Scaricare gl2ps dal sito www.geuz.org/gl2ps/
Scaricare Swig dal sito www.swig.org
Creare il file interfaccia gl2ps.i, e' possibile scaricare e usare questo
Digitare i comandi di Swig swig -python gl2ps.i
Verrà creato un file gl2ps_wrap.c e un file gl2ps.py, immergere gl2ps_wrap.c nei sorgenti scaricati di gl2ps, creare un progetto (ad esempio con Dev). Ecco il file del progetto dev:gl2ps_sw.dev. Il file gl2ps.py va usato nel progetto Python
Compilare il progetto gl2ps con gl2ps_wrap.c, prendere il dll e metterlo in %PYTHON_DIR%\Dlls
Usare gl2ps.py in Python

Nel mio progetto il file gl2ps_wrap.c deve essere rinominato in gl2ps_sw.c per far funzionare il gl2ps_sw.dev.
Occorre far coincidere il nome del file .dll e il nome del file Python importato all'interno del modulo creato (ossia all'inizio di gl2ps.py c'e' un import: verificare che sia uguale al dll)
Per usarlo si devono usare fopen e fclose (e fput) classici del C.

Pattern Observer (Publish/Subscribe)

2006-03-19T02:15:00.000+01:00

GoF : singleton, strategy, observer, facade, composite

Modello non deve conoscere la presentazione

Problema: Differenti oggetti subscriber sono interessati a cambiamenti di stato o eventi per reagire eventualmente, mantenendo basso accoppiamento con publisher

Soluzione: interfaccia Subscriber/Listener implementata da tutti gli interessati

Observer (Property Listener) ha un metodo Update che poi viene implementato dalle classi della Presentazione figlie ,
il Subject (Modello) può inserirsi e togliersi i riferimenti di Observer di ogni figlia e ad ogni notifica li scansiona, i metodi della classe Subject hanno la stessa implementazione per tutte le istanze, per cui Subject viene ovviamente derivata,
l’istanza vista (ConcreteObserver), usando l’evento aggiorna la propria Presentazione.

Inizializzazione:

Il programma principale crea il Modello e la Vista (passando ad essa il Modello),
la Vista fa attaccare (tramite il riferimento appena passato) se stessa al Modello,
chiama un metodo creaController e gli passa il Modello e la Vista,
il Controller tramite il riferimento al Modello passa al Modello se stesso.

Esempio: Python Observer

Linux Scripting: Standard error, output

2006-03-12T00:46:00.000+01:00

cat marco>prova 2>&1

Redirige lo standard error verso lo standard output (al posto di &1 puo' esserci un file)

Scripting Linux: Control

2006-03-12T00:40:00.000+01:00

Nella console la pressione di Control insieme a un carattere provoca diverse reazioni:

B sinistra
F destra
P comando precedente, sopra
N successivo, sotto
A inizio riga
E fine riga
W cancella parola precedente
U cancella intera riga

Scripting Linux: variabili ambiente e shell

2006-03-12T00:30:00.000+01:00

Differenza: quelle di ambiente sono accedibili ai programmi (che le usano per le loro comodita', ad esempio un CLASSPATH di Java)

PROVA=ciao
export PROVA

export trasferisce a spazio memoria per variabili ambiente

Esempio
Creando una variabile di shell e poi avviare una subconsole e una di ambiente con subconsole, la variabile di ambiente "passa", quella di shell no (provare con un echo)

Nella prima console
MARCO=io
GINO=tu
export GINO

konsole

Nella seconda
echo MARCO

echo GINO
tu

Linux Scripting: LS

2006-03-12T00:08:00.000+01:00

ilgenio@ZemanLandia Desktop $ ls -ltFira
totale 167
2317 -rw-r--r--   1 ilgenio users   4298 21 dic  2004 Home.desktop
6042 -rw-r--r--   1 ilgenio users     69 21 dic  2004 .directory
16421 drwxr-xr-x   2 ilgenio users    216 30 gen 20:35 Python/
 112 drwxr-xr-x   3 ilgenio users    192 30 gen 20:35 Altro/
3343 drwxr-xr-x   2 ilgenio users    168  7 feb 17:43 Banca/
 194 drwxr-xr-x   2 ilgenio users    456  7 feb 17:43 calcoloparallelo/
 772 drwxr-xr-x  11 ilgenio users    656  7 feb 17:44 DisCo/
16325 drwxr-xr-x   5 ilgenio users    152 21 feb 22:29 Universita'/
57864 -rw-r--r--   1 ilgenio users 155389 22 feb 00:27 prospetto_spese_commissioni_hb.pdf
59190 drwxr-xr-x   2 ilgenio users    336 11 mar 14:43 Sistemi operativi/
  52 drwx------   9 ilgenio root     368 11 mar 14:44 ./
   4 drwxr-xr-x  50 ilgenio root    2784 12 mar 00:20 ../


Primo carattere dei dieci dopo l'inode:
      The file types are as follows: - for an ordinary file, d  for  a
        directory,  b for a block special device, c for a character spe-
        cial device, l for a symbolic link,  p  for  a  fifo,  s  for  a
        socket.

Opzioni
l: lista dettagliata
t: ordina per timestamp
F: aggiunge / per le directory, | per le pipe, * per gli eseguibili
i: inode
r: ordine inverso
a: file dot

Problema 1: PyGtkGlext per Windows

2006-03-04T20:43:00.000+01:00

Problema
Dove trovare PyGtkGlExt per Windows e Python 2.4?
Soluzione
Ho chiesto nella relativa mailing list e mi e' stato fornito il file, che credo possa mettere tranquillamente qui.
PyGtkGlExt 1.01 per Python 2.4 in Windows

C'e' voluto un po' per trovare PyGtkGlExt per Windows: intanto spiego cos'e'.
PyOpengl permette di aprirti una finestra e gestire il tuo mondo OpenGl li'.
A me serve gestire OpenGl in un riquadro di una piu' generica finestra GTK, nella quale vi siano contemporaneamente molti widget, menu', icone, ecc.
GtkGlExt permette (c'era anche GtkGlArea ma e' caduto in disuso) questa immersione all'interno di una finestra (gtk.Window), tramite i widget posso quindi interagire convenientemente e istantaneamente sul disegno.

GtkGlExt e PyGtkGlExt sono realizzati fondamentalmente per Linux, ma molti stanno cominciando a interagire anche con Windows, per cui ho speranze che queste librerie vengano aggiornate continuamente (per ora lo sono, ma comunque non e' necessario questo aggiornamento continuo).
In questo caso, poiche' il Python 2.4 e' abbastanza recente e il mantenitore ufficiale di PyGtkGlExt si e' un po' dileguato (ma nella mailing list c'e' qualcuno che continua ad aggiornare) ho dovuto cercare qualcuno che trovasse il modo di compilare in Windows e Visual Studio tali sorgenti (comunque sempre disponibili), ho cercato io stesso di compilare tali sorgenti.

Non riuscivo a compilarlo (non avendo Visual Studio usavo DevC++) in quanto mi restituiva un errore di compatibilita': Python e PyGtkGlExt dovevano essere stati compilati con lo stesso compilatore.
Credo che sbattendoci la testa il problema si sarebbe potuto comunque risolvere, ma perche' perderci tempo?

Documentazione

2006-03-04T20:42:00.000+01:00

Innanzitutto mi suggerisco la documentazione ufficiale: la trovo agevolmente sul sito di Python.

DECISIVI sono poi i newsgroup, nei quali ci sono programmatori che rispondono volontariamente alle domande e senza i quali non andrei da nessuna parte (magari piu' avanti daro' un contributo a qualcuno!).
I newsgroup che uso sono:

Prima di fare una domanda sarebbe d'uopo, secondo me,

aver cercato prima con Google
aver cercato una domanda simile sul newsgroup (a tal proposito il servizio Google Groups e' strepitoso)

In genere comunque qualcuno che risponde anche alle domande piu' balzane c'e' sempre, a volte si discute a livelli che vanno oltre alle tecnicita' del Python

Poi devo dire che mi piace Dive into Python che rimanda spesso alla giusta pagina della documentazione ufficiale e spiega passo passo: e' un buon tutorial.

Poi per le PyGtk mi piace http://www.parafernalia.org/pygtk/ che e' stato molto utile per realizzarele prime interfacce, che poi comunque costruisco piu' velocemente con Glade.
Conoscere un minimo le Pygtk e', secondo me (e molti altri a quanto leggo in giro), necessario, per capire come funzionano considerando che se poi con Glade servono comunque, per sapere come interagire con i widget "caricati" da libglade.

Per quanto riguarda le PyGtkGlExt mi sono stati utili gli esempi, coi quali si puo' capire subito come usare le relative API e farsi l'area da disegno sull'interfaccia.

Per quanto riguarda OpenGl, punto di riferimento che ho in questo momento e' OpenGl A primer, di Edward Angel (Second Edition), utile soprattutto per capire bene come usare il glOrtho o il gluPerspective, per capire le trasformazioni, le curve.
Credo pero' che alcuni dettagli manchino (ad esempio, come renderizzare in diversi riquadri contemporaneamente? La cosa mi servira' per creare un output ad alta definizione).

Collegare l'interfaccia al modello in PyGtk, con retroazione da parte dell'interfaccia

2006-03-04T20:41:00.000+01:00

Tale appunto nasce con lo scopo di ricordarmi i passaggi per collegare l'interfaccia al modello, considerando che l'interfaccia assume funzioni di input e output allo stesso tempo.
Faccio riferimento ad un programmino che mi converte i gradi di temperatura nelle diverse rappresentazioni.

Costruire l'interfaccia con Glade

Ricordarsi di impostare il segnale nei widget interessati (value_changed>on_numero_cambiato)

Creare il dizionario che traduce i segnali in funzioni
segnali={"on_numero_cambiato": self.numero_cambiato}
Connettere la parte grafica al modello tramite il dizionario
applicazione.signal_autoconnect (segnali)

Impostare il caricamento dell'interfaccia dal file
file_interfaccia="Gradi.glade"
applicazione=gtk.glade.XML(file_interfaccia)
main=applicazione.get_widget('main')

Definire attributi e metodi accessori del modello, ricordando di usare un protocollo stabilito che colleghi i nomi dei widget ai nomi dei metodi accessori, nel mio caso kelvin e' il nome del widget che gestisce il cambiamento dei gradi kelvin e nella classe ModelloGrado avro' i metodi get_kelvin e set_kelvin
Definire l'accesso dinamico usando funzione getattr, che permette di chiamare un metodo senza sapere a priori, ma solo a tempo d'esecuzione, in base al nome del widget

Codice del mio esempio

import gtk.glade
import gtk
from gtk.gtkgl import *
from ModelloGrado import *
from InterfacciaGrado import *
class Controllo:
  """ Ha il compito di gestire, qui e' implementato velocemente
  (avrebbe dovuto gestire l'elemento corrente e passarlo all'interfaccia)"""
  def __init__(self):
      elemento=ModelloGrado()
      interfaccia=InterfacciaGrado()
      interfaccia.carica_dati(elemento)
      gtk.main()
Controllo()




import gtk.glade
import gtk
from gtk.gtkgl import *
from ModelloGrado import *
class InterfacciaGrado:
  def __init__(self):
      """Carica l'interfaccia da file Glade e vi imposta gli attributi"""
      file_interfaccia="Gradi.glade"                  # Nome del file
      applicazione=gtk.glade.XML(file_interfaccia)    # Carica l'interfaccia
      main=applicazione.get_widget('main')            # Carica la finestra principale

      self.__celsius   = applicazione.get_widget('celsius') # Carica gli spinbutton
      self.__reaumur   = applicazione.get_widget('reaumur')
      self.__kelvin    = applicazione.get_widget('kelvin')
      self.__fahreneit = applicazione.get_widget('fahreneit')

      segnali={"on_numero_cambiato": self.numero_cambiato}
      applicazione.signal_autoconnect (segnali)
      main.show_all()
    
  def carica_dati(self,elemento):
      """ Ha lo scopo di caricare i valori dell'elementi del modello negli widget dell'interfaccia"""
      self.__elemento_corrente=elemento
      self.__semaforo=False                   # Evita che il segnale che i set_value generano
                                              #   non vada a modificare il modello
                                              #   creando un ciclo infinito
      self.__celsius  .set_value(elemento.get_celsius())  # Imposta il valore degli spinbutton
      self.__reaumur  .set_value(elemento.get_reaumur())
      self.__kelvin   .set_value(elemento.get_kelvin())
      self.__fahreneit.set_value(elemento.get_fahreneit())
      self.__semaforo=True
  def numero_cambiato(self,widget):
      nome_widget=widget.get_name()
      testo=widget.get_text().replace(",",".")
    
      if self.__semaforo:                     # Se il segnale non e' dovuto a un set_value
                                              #   vuol dire che viene dall'utente
                                              #   quindi modifica l-attributo del modello
          getattr(self.__elemento_corrente,"set_"+nome_widget)(float(testo))
          self.carica_dati(self.__elemento_corrente)



class ModelloGrado:
  """ Non ha altre funzioni se non la gestione dei propri attributi"""
  def __init__(self):
      self.__grado=0
  def get_celsius(self):
      return self.__grado
  def set_celsius(self,grado):
      self.__grado=grado
  def get_reaumur(self):
      return self.__grado*80/100
  def set_reaumur(self,reaumur):
      self.__grado=reaumur*100/80
  def get_fahreneit(self):
      return 32+(self.__grado*180/100)
  def set_fahreneit(self,fahreneit):
      self.__grado=(fahreneit-32)*100/180
  def get_kelvin(self):
      return self.__grado+273.15
  def set_kelvin(self,kelvin):
      self.__grado=kelvin-273.15