LE BLOG DE YOANN

Alice In Chains

2010-10-31T07:13:00.000-07:00

Petit retour sur un groupe mythique des années 80/90, Alice In Chains, le blog de yusuf retrace l'histoire de ce groupe (très bien détaillé)
http://yusuf-filth.blogspot.com/2008/12/alice-in-chains.html

un de ses membre, layne staley, mort en 2002 a écrit /interprété quelques excellentissimes morceau de ce groupe

nutshell:

Would ?:
http://www.youtube.com/watch?v=QA8Vq4nEkQc&ob=av2n

FC2 : module TEWS

2010-05-11T14:33:00.000-07:00

Ce module est très simple, il avance très vite, il reste à implémenter les affichages graphique en fonction du type de signal (tracking/scan/missile) et surtout tester les différentes cibles afin de renseigner le fichier text de donnée cible

petite copie d'écran avec le module carte :

FC2 : Application Carte

2010-05-10T10:02:00.000-07:00

L'application carte fonctionne , la fonction de corrélation est débuggée, voilà ce que cela donne en préparation de mission :

et voilà ce que cela donne lors du déroulement du jeux :

La fonction "BRAA" n'est pas implémentée, elle sera peut être nécessaire à voir à l'usage ....

L'utilisation d'icônes spécifiques est peut être à envisager

LINUX : CONVERSION DE FICHIER VIDEO

2010-05-09T13:21:00.000-07:00

Petit lien qui rappelle comment convertir des fichiers en utilisant Mencoder (mplayer)

http://www.commentcamarche.net/faq/8183-comment-convertir-un-clip-video-en-flv-et-inversement#sous-linux

mencoder -ovc help
donne la liste des codec utilisables en ecriture ...
mencoder out-1.ogv -ovc lavc -o video2.avi

LINUX DEBIAN : installation du drivers propriétaire debian

2010-05-09T02:33:00.001-07:00

petit article bien clair qui explique installation des drivers nvidia sous débian testing :
http://geekeries.de-labrusse.fr/?p=31#comments

FC2 : Application Carte, mise à jour du terrain (Mise à Jour)

2010-05-08T07:58:00.000-07:00

après modification du script de conversion et récupération des données du site USGS voici la nouvelle carte
les corrections d'erreur ont été automatisée dans le nouveaux script et le gain de temps est important.
L'interface avec lock on FC2 est fonctionnelle et permet l'affichage des avions + piste d'atterrissage

- afficher des infos groupée si on a des vols en formations (<500m et vecteur vitesse similaire)--> Fonctionnel

- afficher le nom des bases/aéroports --> Fonctionnel

- calcul de BRAA

- changer en fonction de la mission la coalition des aeroport (nouveaux avec FC2) --> Fonctionnel
@+
Nota : il est compatible windows et linux ....

FC2 : application carte en cours de jeux

2010-05-06T22:54:00.000-07:00

FC2 : Installation de Tacview et modification proposée

2010-04-15T13:00:00.000-07:00

Le tacview black shark fonctionne très bien pour FC2, toutefois le fichier généré est énorme car sont stockés :
- les même objets que pour FC1
- les éclats et trajectoires obus !!!!
voici le film pour l'install

http://www.youtube.com/watch?v=gOYJ33oFbTo

en complément ci dessous le fichier tacview modifié :

-- Tacview ACMI - Universal Flight Analysis Tool 0.94
-- Export script for DCS: Black Shark
-- Copyright (C) 2006-2009 - Stra Software
-- See http://lomac.strasoftware.com/lomac-acmi.php for more info

-- ACMI text files are exported to [/Black Shark/Temp/] folder

-- TO ENABLE THIS SCRIPT:
--        Set [EnableExportScript = true] in [/Black Shark/Config/export/config.lua]
--        Add [dofile("./Config/Export/TacviewExportBlackShark.lua")] at the end of [/Black Shark/Config/Export/Export.lua]

-- Headers
dofile("./Config/World/World.lua")                -- Required to get mission date
dofile("./Scripts/Database/wsTypes.lua")        -- Required to get object types definitions

-- Debug tools
function table.val_to_str ( v )
    if "string" == type( v ) then
        v = string.gsub( v, "\n", "\\n" )
        if string.match( string.gsub(v,"[^'\"]",""), '^"+$' ) then
            return "'" .. v .. "'"
        end
        return '"' .. string.gsub(v,'"', '\\"' ) .. '"'
    else
        return "table" == type( v ) and table.tostring( v ) or tostring( v )
    end
end

function table.key_to_str ( k )
    if "string" == type( k ) and string.match( k, "^[_%a][_%a%d]*$" ) then
        return k
    else
        return "[" .. table.val_to_str( k ) .. "]"
    end
end

function table.tostring( tbl )
    local result, done = {}, {}
    for k, v in ipairs( tbl ) do
        table.insert( result, table.val_to_str( v ) )
        done[ k ] = true
    end
    for k, v in pairs( tbl ) do
        if not done[ k ] then
            table.insert( result,
            table.key_to_str( k ) .. "=" .. table.val_to_str( v ) )
        end
    end
    return "{" .. table.concat( result, "," ) .. "}"
end

-- Terrain exporter
function ExportTerrain()

--[[
    -- ge (Black Shark)
    ExportSector(40,41);
    ExportSector(40,42);
    ExportSector(40,43);
    ExportSector(40,44);
    ExportSector(41,41);
    ExportSector(41,42);
    ExportSector(41,43);
    ExportSector(41,44);
    ExportSector(42,40);
    ExportSector(42,41);
    ExportSector(42,42);
    ExportSector(42,43);
    ExportSector(42,44);

    -- ru (Black Shark)
    ExportSector(43,39);
    ExportSector(43,40);
    ExportSector(43,41);
    ExportSector(43,42);
    ExportSector(43,43);
    ExportSector(43,44);
    ExportSector(44,37);
    ExportSector(44,38);
    ExportSector(44,39);
    ExportSector(44,40);
    ExportSector(44,41);
    ExportSector(44,42);
    ExportSector(44,43);
    ExportSector(44,44);
    ExportSector(45,37);
    ExportSector(45,38);
    ExportSector(45,39);
    ExportSector(45,40);

    -- ua (Flaming Cliffs)
    ExportSector(44,33);
    ExportSector(44,34);
    ExportSector(44,35);
    ExportSector(45,32);
    ExportSector(45,33);
    ExportSector(45,34);
    ExportSector(45,35);
    ExportSector(45,36);
--]]

end

function ExportSector(Latitude,Longitude)

    local TerrainFile=io.open(string.format("./Temp/N%02uE%03u.hgt.txt",Latitude,Longitude),"wb");

    for y=1200,0,-1 do

        local CurrentLatitude=Latitude+y/1200;

        for x=0,1200 do

            local CurrentLongitude=Longitude+x/1200;
            local DCSCoordinates=LoGeoCoordinatesToLoCoordinates(CurrentLongitude,CurrentLatitude);

            TerrainFile:write(LoGetAltitude(DCSCoordinates.x,DCSCoordinates.z).."\n");

        end
    end

    io.close(TerrainFile);
end

-- ACMI Log
AcmiData=
{
    -- Log parameters
    DefaultObjectsUpdatePeriod=1/10,    -- Delay between two log updates (in seconds) for default objects, use [0] to force update at each frame
    BallisticObjectsUpdatePeriod=1/2,    -- Delay between two log updates (in seconds) for ballistic objects, use [0] to force update at each frame
    LatitudeOffset=41,                    -- To improve log resolution
    LongitudeOffset=36,                    -- To improve log resolution

    -- Convert Lock-On Object_Type To Tacview Object_Type
    ObjectTypeLookupTable=
    {
        [wsType_Destroyed]                    =    0x46,    -- Shrapnel (e.g. Cluster-bomb fragments or exploded plane parts)
        [wsType_Air]=
        {
            [-1]                            =    0x10,    -- Aeroplanes (including fixed-wing drones)
            [wsType_Helicopter]                =    0x18,    -- Helicopters (including rotary-wing drones)
            [wsType_Airplane]=
            {
                [-1]                        =    0x10,    -- Aeroplanes (including fixed-wing drones)
                [wsType_Fighter]            =    0x10,    -- Aeroplanes (including fixed-wing drones)
                [wsType_F_Bomber]            =    0x10,    -- Aeroplanes (including fixed-wing drones)
                [wsType_Intercepter]        =    0x10,    -- Aeroplanes (including fixed-wing drones)
                [wsType_Intruder]            =    0x10,    -- Aeroplanes (including fixed-wing drones)
                [wsType_Cruiser]            =    0x10,    -- Aeroplanes (including fixed-wing drones)
                [wsType_Battleplane]        =    0x10,    -- Aeroplanes (including fixed-wing drones)
            },
            [wsType_Free_Fall]=
            {
                [-1]                        =    0x46,    -- Shrapnel (e.g. Cluster-bomb fragments or exploded plane parts)
                [wsType_Snars]=
                {
                    [-1]                    =    0x46,    -- Shrapnel (e.g. Cluster-bomb fragments or exploded plane parts)
                    [wsType_Chaff]            =    0x50,    -- Chaff (obviously a chaff cluster)
                    [wsType_Flare]            =    0x54,    -- Flare
                },
                [wsType_Parts]=
                {
                    [-1]                    =    0x46,    -- Shrapnel (e.g. Cluster-bomb fragments or exploded plane parts)
                    [203]                    =    0x60,    -- Minor object (e.g. cartridge)
                },
                [wsType_FuelTank]            =    0x46,    -- Shrapnel (e.g. Cluster-bomb fragments or exploded plane parts)
            },
        },
        [wsType_Ground]=
        {
            [-1]                            =    0x28,    -- Light/Unarmed vehicles
            [wsType_Tank]=
            {
                [-1]                        =    0x24,    -- Armored fighting vehicle
                [wsType_NoWeapon]=
                {
                    [-1]                    =    0x28,    -- Light/Unarmed vehicles
                    [wsTypePredator_GCS]     =    0x28,    -- Light/Unarmed vehicles
                    [wsTypePredator_TrojanSpirit]=0x28,    -- Light/Unarmed vehicles
                },
                [wsType_Gun]=
                {
                    [-1]                    =    0x24,    -- Armored fighting vehicle
                    [wsTypeSandbox]            =    0x89,    -- Building
                    [wsTypeBunker]            =    0x89,    -- Building
                    [wsTypeAutogun]            =    0x2c,    -- Infantry
                    [wsTypeSoldier_AK]       =    0x2c,    -- Infantry
                },
                [wsType_MissGun]=
                {
                    [-1]                    =    0x24,    -- Armored fighting vehicle
                    [wsTypeRPG]                =    0x2c,    -- Infantry
                    [wsTypeSoldier_RPG]     =    0x2c,    -- Infantry
                },
            },
            [wsType_SAM]                    =    0x20,    -- Anti-aircraft warfare (usually: SAM and AAA)
            [wsType_Moving]=
            {
                [-1]                        =    0x28,    -- Light/Unarmed vehicles
                [wsType_NoWeapon]            =    0x28,    -- Light/Unarmed vehicles
                [wsType_Gun]                =    0x28,    -- Light/Unarmed vehicles
                [wsType_Miss]                =    0x24,    -- Armored fighting vehicle
                [wsType_ChildMiss]            =    0x24,    -- Armored fighting vehicle
                [wsType_MissGun]            =    0x24,    -- Armored fighting vehicle
                [wsType_Civil]                =    0x28,    -- Light/Unarmed vehicles
            },
            [wsType_Standing]=
            {
                [-1]                        =    0x89,    -- Building
                [wsType_NoWeapon]            =    0x89,    -- Building
                [wsType_Gun]                =    0x89,    -- Building
                [wsType_Miss]                =    0x20,    -- Anti-aircraft warfare (usually: SAM and AAA)
                [wsType_ChildMiss]            =    0x20,    -- Anti-aircraft warfare (usually: SAM and AAA)
                [wsType_MissGun]            =    0x20,    -- Anti-aircraft warfare (usually: SAM and AAA)
                [wsType_Civil]                =    0x89,    -- Building
            },
        },
        [wsType_Navy]=
        {
            [-1]                            =    0x30,    -- Armed Watercraft (including submarines)
            [wsType_Ship]=
            {
                [-1]                        =    0x30,    -- Armed Watercraft (including submarines)
                [wsType_AirCarrier]            =    0x34,    -- Aircraft carrier (including Helicopter carrier)
                [wsType_HCarrier]            =    0x34,    -- Aircraft carrier (including Helicopter carrier)
                [wsType_ArmedShip]            =    0x30,    -- Armed Watercraft (including submarines)
                [wsType_CivilShip]            =    0x38,    -- Light/Unarmed Watercraft
            },
        },
        [wsType_Weapon]=
        {
            [-1]                            =    0x40,    -- Missile (guided missiles)
            [wsType_Missile]=
            {
                [-1]                        =    0x40,    -- Missile (guided missiles)
                [wsType_AA_Missile]            =    0x40,    -- Missile (guided missiles)
                [wsType_AS_Missile]            =    0x40,    -- Missile (guided missiles)
                [wsType_SA_Missile]            =    0x40,    -- Missile (guided missiles)
                [wsType_SS_Missile]            =    0x40,    -- Missile (guided missiles)
                [wsType_AA_TRAIN_Missile]    =    0x40,    -- Missile (guided missiles)
                [wsType_AS_TRAIN_Missile]    =    0x40,    -- Missile (guided missiles)
            },
            [wsType_Bomb]=
            {
                [-1]                        =    0x4c,    -- Bomb (guided and unguided)
                [wsType_Bomb_A]                =    0x4c,    -- Bomb (guided and unguided)
                [wsType_Bomb_Guided]        =    0x4c,    -- Bomb (guided and unguided)
                [wsType_Bomb_BetAB]            =    0x4c,    -- Bomb (guided and unguided)
                [wsType_Bomb_Cluster]        =    0x4c,    -- Bomb (guided and unguided)
                [wsType_Bomb_Antisubmarine]    =    0x4c,    -- Bomb (guided and unguided)
                [wsType_Bomb_ODAB]            =    0x4c,    -- Bomb (guided and unguided)
                [wsType_Bomb_Fire]            =    0x4c,    -- Bomb (guided and unguided)
                [wsType_Bomb_Nuclear]        =    0x4c,    -- Bomb (guided and unguided)
                [wsType_Bomb_Lighter]        =    0x4c,    -- Bomb (guided and unguided)
            },
            [wsType_Shell]=
            {
                [-1]                        =    0x48,    -- Shell
                [wsType_Shell_A]            =    0x48,    -- Shell
            },
            [wsType_NURS]=
            {
                [-1]                        =    0x44,    -- Rocket (unguided missiles)
                [wsType_Container]            =    0x44,    -- Rocket (unguided missiles)
                [wsType_Rocket]                =    0x44,    -- Rocket (unguided missiles)
            },
        },
        [wsType_Static]=
        {
            [-1]                            =    0x89,    -- Building
            [wsType_AirdromePart]            =    0x89,    -- Building
            [wsType_WingPart]                =    0x89,    -- Building
            [wsType_Free_Fall]=
            {
                [-1]                        =    0x46,    -- Shrapnel (e.g. Cluster-bomb fragments or exploded plane parts)
                [wsType_Parts]=
                {
                    [-1]                    =    0x46,    -- Shrapnel (e.g. Cluster-bomb fragments or exploded plane parts)
                    [255]                    =    -1,        -- Particles (e.g. landing gear dust on runway)
                },
            },
            [wsType_Airdrome]=
            {
                [-1]                        =    0x81,    -- Aerodrome
                [wsType_RW1]                =    0x81,    -- Aerodrome
                [wsType_RW2]                =    0x81,    -- Aerodrome
                [wsType_Heliport]            =    0x81,    -- Aerodrome
            },
            [wsType_Explosion]=
            {
                [-1]                        =    0x46,    -- Shrapnel (e.g. Cluster-bomb fragments or exploded plane parts)
                [wsType_GroundExp]            =    0x46,    -- Shrapnel (e.g. Cluster-bomb fragments or exploded plane parts)
            },
            [wsType_GContainer]=
            {
                [-1]                        =    0x46,    -- Shrapnel (e.g. Cluster-bomb fragments or exploded plane parts)
                [wsType_Control_Cont]        =    0x46,    -- Shrapnel (e.g. Cluster-bomb fragments or exploded plane parts)
                [wsType_Jam_Cont]            =    0x46,    -- Shrapnel (e.g. Cluster-bomb fragments or exploded plane parts)
                [wsType_Cannon_Cont]        =    0x46,    -- Shrapnel (e.g. Cluster-bomb fragments or exploded plane parts)
                [wsType_Support]            =    0x46,    -- Shrapnel (e.g. Cluster-bomb fragments or exploded plane parts)
                [wsType_Snare_Cont]            =    0x46,    -- Shrapnel (e.g. Cluster-bomb fragments or exploded plane parts)
                [wsType_Smoke_Cont]            =    0x46,    -- Shrapnel (e.g. Cluster-bomb fragments or exploded plane parts)
            },
        },
    },

    -- Convert Lock-On Coalition_ID To Tacview Coalition_ID
    CoalitionLookupTable=
    {
        ["Allies"]            =    0,
        ["Enemies"]            =    1,
    },

    -- Convert Lock-On Country_Name To ISO Country_Code
    CountryCodeLookupTable=
    {
        [ 0]                =    "ru",
        [ 1]                =    "ua",
        [ 2]                =    "us",
        [ 3]                =    "tr",
        [ 4]                =    "uk",
        [ 5]                =    "fr",
        [ 6]                =    "de",
--        [ 7]                =    "",
        [ 8]                =    "ca",
        [ 9]                =    "es",
        [10]                =    "nl",
        [11]                =    "be",
        [12]                =    "no",
        [13]                =    "dk",
--        [14]                =    "",
        [15]                =    "il",
        [16]                =    "ge",
        [17]                =    "xi",        -- [Insurgents] (free for use ISO code)
    },

    -- Reduce ID size (to compact text log)
    -- OptimizedID=ID^0x1000000 (free in C, hard to do with LUA...)
    GetOptimizedID=function(ID)

        if math.mod(math.floor(ID/0x1000000),2)==1 then
            return ID-0x1000000;    -- Clear bit
        end

        return ID+0x1000000;        -- Set bit
    end,

    -- Trim Given String
    Trim=function(StringToTrim)
        return string.gsub(StringToTrim,"^%s*(.-)%s*$","%1");
    end,

    -- Add escape characters
    DecorateName=function(Name)

        if Name then
            Name=string.gsub(Name,"\\","\\\\");
            Name=string.gsub(Name,",","\\,");
            Name=string.gsub(Name,"=","\\=");
            return Name;
        end

        return "";
    end,

    -- Trim and decorate name for log output
    CleanupName=function(Name)
        return AcmiData.DecorateName(AcmiData.Trim(Name));
    end,

    -- Convert Lock-On unit type to Tacview unit type
    ConvertObjectType=function(LockOnObjectType)

        local TacviewObjectType;

        TacviewObjectType=AcmiData.ObjectTypeLookupTable[LockOnObjectType.level1];

        if not TacviewObjectType then
            return AcmiData.ObjectTypeLookupTable[-1];
        end

        if type(TacviewObjectType)~="table" then
            return TacviewObjectType;
        end

         TacviewObjectType=AcmiData.ObjectTypeLookupTable[LockOnObjectType.level1][LockOnObjectType.level2];

        if not TacviewObjectType then
            return AcmiData.ObjectTypeLookupTable[LockOnObjectType.level1][-1];
        end

        if TacviewObjectType and type(TacviewObjectType)~="table" then
            return TacviewObjectType;
        end

         TacviewObjectType=AcmiData.ObjectTypeLookupTable[LockOnObjectType.level1][LockOnObjectType.level2][LockOnObjectType.level3];

        if not TacviewObjectType then
            return AcmiData.ObjectTypeLookupTable[LockOnObjectType.level1][LockOnObjectType.level2][-1];
        end

        if TacviewObjectType and type(TacviewObjectType)~="table" then
            return TacviewObjectType;
        end

         TacviewObjectType=AcmiData.ObjectTypeLookupTable[LockOnObjectType.level1][LockOnObjectType.level2][LockOnObjectType.level3][LockOnObjectType.level4];

        if not TacviewObjectType then
            return AcmiData.ObjectTypeLookupTable[LockOnObjectType.level1][LockOnObjectType.level2][LockOnObjectType.level3][-1];
        end

         return TacviewObjectType;
    end,

    -- Begin to log ACMI data
    BeginLog=function(self)

        -- Reset objects lists
        self.LastObjectsStatus={};        -- Last frame object status
        self.LoggedObjectsStatus={};    -- Last logged object status (usually older than LastObjectsStatus)

        -- Reset tools
        self.NextDefaultObjectsUpdateTime=0;
        self.NextBallisticObjectsUpdateTime=0;

        -- Create a new log file for each mission
        self.AcmiFile=io.open("./Temp/Tacview-"..os.date("%Y%m%d-%H%M%S")..".txt.acmi","wb");

        if not self.AcmiFile then
            return;
        end

        -- UTF-8 BOM header
        self.AcmiFile:write(string.char(0xEF,0xBB,0xBF));

        -- Core Header
        self.AcmiFile:write("FileType=text/acmi/tacview\n");
        self.AcmiFile:write("FileVersion=1.2\n");
        self.AcmiFile:write("Source=LOCK ON Flaming Cliff 2.0\n");
        self.AcmiFile:write("Recorder=Tacview 0.94\n");
        self.AcmiFile:write("RecordingTime="..os.date("!%Y-%m-%dT%H:%M:%SZ",now).."\n");

        local PlayerName=LoGetPilotName();

        if PlayerName then
            self.AcmiFile:write("Author="..self.CleanupName(PlayerName).."\n");
        end

        -- Declarations
        if MissionDate then

            -- Crimea Time Zone: Winter(UTC+2) Summer(DST=UTC+3)
            -- 3 hours time shift calculation (assume summer Crimea time shift)
            local LocalRefTime=os.time{year=2004,month=6,day=22,hour=0};
            local UTCRefTime=os.time{year=2004,month=6,day=21,hour=21};
            local TimeShift=LocalRefTime-UTCRefTime;

            -- Need to manualy apply DST bias because nothing is simple with LUA
            local CurrentDate=os.date("*t",now);
            local IsDst;

            if CurrentDate and CurrentDate.isdst==true then
                IsDst=true;
            else
                IsDst=false;
            end

            -- Substract 3 hours from the current mission time (not easy with lua)
            local LocalMissionTime=os.time{year=MissionDate.Year,month=MissionDate.Month,day=MissionDate.Day,hour=0,isdst=IsDst};
            local UTCMissionTime=LocalMissionTime-TimeShift+LoGetMissionStartTime();
            local MissionTimeTable=os.date("*t",UTCMissionTime);

            self.AcmiFile:write("MissionTime="..string.format("%04u-%02u-%02uT%02u:%02u:%02uZ",MissionTimeTable.year,MissionTimeTable.month,MissionTimeTable.day,MissionTimeTable.hour,MissionTimeTable.min,MissionTimeTable.sec).."\n");
        end

        self.AcmiFile:write("LatitudeOffset="..self.LatitudeOffset.."\n");
        self.AcmiFile:write("LongitudeOffset="..self.LongitudeOffset.."\n");
        self.AcmiFile:write("Coalition=Allies,Red\n");
        self.AcmiFile:write("Coalition=Enemies,Blue\n");
        self.AcmiFile:write("ProvidedEvents=Removed\n");

        -- Additional Information
        local PlayerID=LoGetPlayerPlaneId();

        if PlayerID then
            self.AcmiFile:write(string.format("MainAircraftID=%x\n",self.GetOptimizedID(PlayerID)));
        end
    end,

    -- Update ACMI log
    UpdateLog=function(self)

        -- Check parameters
        if not AcmiData.AcmiFile then
            return;
        end

        -- Format current frame time
        local CurrentTime=LoGetModelTime();
        local FormatedTime=string.format("#%.2f\n",CurrentTime);
        local ShouldUpdateLog=true;

        -- Add/Update default objects
        if CurrentTime>=self.NextDefaultObjectsUpdateTime then
            ShouldUpdateLog=true;
            self.NextDefaultObjectsUpdateTime=CurrentTime+self.DefaultObjectsUpdatePeriod;
        end

        local DefaultObjectsList=LoGetWorldObjects();    -- LoGetWorldObjects("units");

        if self:AddUpdateObjects(DefaultObjectsList,FormatedTime,ShouldUpdateLog)==true then
            FormatedTime=nil;
        end

        -- Add/Update ballistic objects
        if CurrentTime>=self.NextBallisticObjectsUpdateTime then
            ShouldUpdateLog=true;
            self.NextBallisticObjectsUpdateTime=CurrentTime+self.BallisticObjectsUpdatePeriod;
        end

        local BallisticObjectsList=LoGetWorldObjects("ballistic");

        if self:AddUpdateObjects(BallisticObjectsList,FormatedTime,ShouldUpdateLog)==true then
            FormatedTime=nil;
        end

        -- Remove destroyed objects
        self:RemoveObjects(DefaultObjectsList,BallisticObjectsList,FormatedTime);
    end,

    -- Add/Update objects
    AddUpdateObjects=function(self,CurrentObjectsList,FormatedTime,ShouldUpdateLog)

        -- Check parameters
        if not CurrentObjectsList then
            return false;
        end

        -- Dump objects
        local LogWasUpdated=false;

        for ID,Object in pairs(CurrentObjectsList) do

            -- Check Object Type
            local ObjectType=self.ConvertObjectType(Object.Type);

            if ObjectType~=-1 then    -- Ignore some objects (like particles clouds)

                -- Reduce ID size (to compact text log)
                local OptimizedID=self.GetOptimizedID(ID);

                -- Add new object
                if not self.LastObjectsStatus[ID] then

                    local LogLine;

                    -- Time prefix
                    if FormatedTime then
                        LogLine=FormatedTime;
                        FormatedTime=nil;
                    else
                        LogLine="";
                    end

                    -- Object/Pilot Name
                    local ObjectName=Object.Name;
                    local PilotName;

                    if Object.UnitName then
                        PilotName=Object.UnitName;
                    else
                        PilotName="";
                    end

                    -- Object Type
                    local ObjectTypeFormated;

                    if ObjectType and type(ObjectType)=="number" then
                        ObjectTypeFormated=string.format("%x",ObjectType);
                    else
                        -- This will help to track unknown types
                        ObjectTypeFormated=string.format("%s.%s.%s.%s",Object.Type.level1,Object.Type.level2,Object.Type.level3,Object.Type.level4);
                    end

                    -- Coalition
                    local CoalitionID;

                    if ObjectType==0x48 or ObjectType==0x50 or ObjectType==0x54 then
                        CoalitionID="?";            -- Chaff/Flare/Shell coalition is not reliable in DCS
                    else
                        if Object.Coalition then
                            CoalitionID=self.CoalitionLookupTable[Object.Coalition];

                            if not CoalitionID then
                                CoalitionID="?";
                            end
                        else
                            CoalitionID="?";
                        end
                    end

                    -- Country
                    local CountryCode;

                    if Object.Country then
                        CountryCode=self.CountryCodeLookupTable[Object.Country];

                        if not CountryCode then
                            CountryCode="?";
                        end
                    else
                        CountryCode="?";
                    end

                    -- Group Name
                    local GroupName;

                    if Object.GroupName then
                        GroupName=Object.GroupName;
                    else
                        GroupName="?";
                    end
                    -- modification yoann suppression des shrapnels
                    if ObjectType ~= 0x46 then
                        -- Declare new object
                        self.AcmiFile:write(LogLine..string.format("+%x,?,%s,%s,%s,%s,%s,%s,?\n",OptimizedID,ObjectTypeFormated,CoalitionID,CountryCode,self.CleanupName(ObjectName),self.CleanupName(PilotName),self.CleanupName(GroupName)));

                    -- Done
                        LogWasUpdated=true;
                    end
                end

                -- Update object data as required
                --
                -- modification yoann suppression des shrapnels

                if ObjectType ~= 0x46 then
                    if self:UpdateObject(ID,Object,ObjectType,self.LoggedObjectsStatus[ID],FormatedTime,ShouldUpdateLog)==true then
                        FormatedTime=nil;
                        LogWasUpdated=true;
                    end
                end
            end
        end

        -- Completed
        return LogWasUpdated;
    end,

    -- Fix Yaw (because FC/BS map is a 2D projection, not a true 3D sphere)
    FixedYaw=function(Yaw,RefX,RefZ,Latitude,Longitude)

        local ToNorthPos=LoGeoCoordinatesToLoCoordinates(Longitude,Latitude+.001);

        local ToNorthX=ToNorthPos.z-RefZ;
        local ToNorthY=ToNorthPos.x-RefX;

        local ToNorthLength=math.sqrt(ToNorthX*ToNorthX+ToNorthY*ToNorthY);

        if ToNorthLength>0 then
            return Yaw-math.asin(ToNorthX/ToNorthLength);
        end

        return Yaw;
    end,

    -- Update one object
    UpdateObject=function(self,ID,CurrentObjectData,ObjectType,PrevObjectData,FormatedTime,ShouldUpdateLog)

        -- Log object dynamic properties
        local ChangeDetected=false;
        local LogWasUpdated=false;
        local Log="";

        -- Latitude
        if not PrevObjectData or CurrentObjectData.LatLongAlt.Lat~=PrevObjectData.LatLongAlt.Lat then
            Log=Log..string.format(",%.6f",CurrentObjectData.LatLongAlt.Lat-self.LatitudeOffset);
            ChangeDetected=true;
        else
            Log=Log..",";
        end

        -- Longitude
        if not PrevObjectData or CurrentObjectData.LatLongAlt.Long~=PrevObjectData.LatLongAlt.Long then
            Log=Log..string.format(",%.6f",CurrentObjectData.LatLongAlt.Long-self.LongitudeOffset);
            ChangeDetected=true;
        else
            Log=Log..",";
        end

        -- Altitude
        if not PrevObjectData or CurrentObjectData.LatLongAlt.Alt~=PrevObjectData.LatLongAlt.Alt then
            Log=Log..string.format(",%.2f",CurrentObjectData.LatLongAlt.Alt);
            ChangeDetected=true;
        else
            Log=Log..",";
        end

        -- Roll/Pitch/Yaw
        if ObjectType==0x48 or ObjectType==0x50 or ObjectType==0x54 then    -- flare/chaff/shell

            -- Do not log roll/pitch/yaw to reduce recording size
            if not PrevObjectData then
                Log=Log..",0,0,0\n";
            else
                Log=Log..",,,\n";
            end

        else

            if ObjectType==0x4c and CurrentObjectData.Name=="" then

                -- Emulate bomblets orientation
                if not PrevObjectData then
                    Log=Log..",?,?,?\n";
                else
                    Log=Log..",,,\n";
                end

            else

                -- Roll
                if not PrevObjectData or CurrentObjectData.Bank~=PrevObjectData.Bank then

                    local NewFormatedRoll=string.format(",%.1f",math.mod(math.deg(CurrentObjectData.Bank),360));
                    local RollIsDifferent=true;

                    if PrevObjectData then

                        local OldFormatedRoll=string.format(",%.1f",math.mod(math.deg(PrevObjectData.Bank),360));

                        if NewFormatedRoll==OldFormatedRoll then
                            RollIsDifferent=false;
                        end
                    end

                    if RollIsDifferent==true then
                        Log=Log..NewFormatedRoll;
                        ChangeDetected=true;
                    else
                        Log=Log..",";        -- not different enougth to be dumped
                    end

                else
                    Log=Log..",";
                end

                -- Pitch
                if not PrevObjectData or CurrentObjectData.Pitch~=PrevObjectData.Pitch then

                    local NewFormatedPitch=string.format(",%.1f",-math.mod(math.deg(-CurrentObjectData.Pitch),360));
                    local PitchIsDifferent=true;

                    if PrevObjectData then

                        local OldFormatedPitch=string.format(",%.1f",-math.mod(math.deg(-PrevObjectData.Pitch),360));

                        if NewFormatedPitch==OldFormatedPitch then
                            PitchIsDifferent=false;
                        end
                    end

                    if PitchIsDifferent==true then
                        Log=Log..NewFormatedPitch;
                        ChangeDetected=true;
                    else
                        Log=Log..",";        -- not different enougth to be dumped
                    end

                else
                    Log=Log..",";
                end

                -- Yaw
                if not PrevObjectData or CurrentObjectData.Heading~=PrevObjectData.Heading then

                    local NewFormatedYaw=string.format(",%.1f\n",math.mod(math.deg(AcmiData.FixedYaw(CurrentObjectData.Heading,CurrentObjectData.Position.x,CurrentObjectData.Position.z,CurrentObjectData.LatLongAlt.Lat,CurrentObjectData.LatLongAlt.Long)),360));
                    local YawIsDifferent=true;

                    if PrevObjectData then

                        local OldFormatedYaw=string.format(",%.1f\n",math.mod(math.deg(AcmiData.FixedYaw(PrevObjectData.Heading,PrevObjectData.Position.x,PrevObjectData.Position.z,PrevObjectData.LatLongAlt.Lat,PrevObjectData.LatLongAlt.Long)),360));

                        if NewFormatedYaw==OldFormatedYaw then
                            YawIsDifferent=false;
                        end
                    end

                    if YawIsDifferent==true then
                        Log=Log..NewFormatedYaw;
                        ChangeDetected=true;
                    else
                        Log=Log..",\n";        -- not different enougth to be dumped
                    end

                else
                    Log=Log..",\n";
                end
            end
        end

        -- Log data
        if not PrevObjectData or ( ChangeDetected==true and ShouldUpdateLog==true ) then

            local OptimizedID=self.GetOptimizedID(ID);

            if FormatedTime then
                self.AcmiFile:write(FormatedTime..string.format("%x",OptimizedID)..Log);
            else
                self.AcmiFile:write(string.format("%x",OptimizedID)..Log);
            end

            LogWasUpdated=true;

            -- Remember Last Logged Object Properties
            self.LoggedObjectsStatus[ID]=CurrentObjectData;
        end

        -- Remember Current Frame Object Properties
        self.LastObjectsStatus[ID]=CurrentObjectData;

        -- Complete
        return LogWasUpdated;
    end,

    -- Remove any destroyed objects
    RemoveObjects=function(self,DefaultObjectsList,BallisticObjectsList,FormatedTime)

        local Log;

        for ID,Object in pairs(self.LastObjectsStatus) do

            if (not DefaultObjectsList or not DefaultObjectsList[ID]) and (not BallisticObjectsList or not BallisticObjectsList[ID]) then

                -- Log last position if required
                local ObjectType=self.ConvertObjectType(Object.Type);

                if self:UpdateObject(ID,Object,ObjectType,self.LoggedObjectsStatus[ID],FormatedTime,true)==true then
                    FormatedTime=nil;
                end

                -- Prefix event with time if required
                if FormatedTime then
                    Log=FormatedTime;
                    FormatedTime=nil;
                else
                    Log="";
                end

                -- Log Event
                self.AcmiFile:write(Log..string.format("!20,%x\n",self.GetOptimizedID(ID)));

                -- Remove object from lists
                self.LoggedObjectsStatus[ID]=nil;
                self.LastObjectsStatus[ID]=nil;
            end
        end
    end,

    -- Stop ACMI logging
    EndLog=function(self)
        if self.AcmiFile then
            io.close(self.AcmiFile);
        end
    end,
}

-- (Hook) Works once right before mission start.
do
    local PrevLuaExportStart=LuaExportStart;

    LuaExportStart=function()

        ExportTerrain();

        AcmiData:BeginLog();

        if PrevLuaExportStart then
            PrevLuaExportStart();
        end
    end
end

-- (Hook) Works right after every simulation frame.
do
    local PrevLuaExportAfterNextFrame=LuaExportAfterNextFrame;

    LuaExportAfterNextFrame=function()
        AcmiData:UpdateLog();

        if PrevLuaExportAfterNextFrame then
            PrevLuaExportAfterNextFrame();
        end
    end
end

-- (Hook) Works once right after mission stop.
do
    local PrevLuaExportStop=LuaExportStop;

    LuaExportStop=function()
        AcmiData:EndLog();

        if PrevLuaExportStop then
            PrevLuaExportStop();
        end
    end
end

Premiers vol avec la BAF sous FC2

2010-04-15T12:52:00.000-07:00

la premiere mission sous FC2 est un succès, reste à s'adapter à l'IA qui est moins "predicitible" que sur l'ancienne version, le radar du F15 est également plus pointu, notamment sur la gestion de la PRF

Module carte "in progress²" il est presque terminé

2010-04-05T13:46:00.000-07:00

Le module carte est en bonne voie :

la com avec lock on est fonctionnelle
l'affichage des symbole est possible
la suppression de symbole est possible

reste à faire :

la supression de objets qui n'existe plus (suite à crash/destruction)
l'affichages des pistes
affichage BRAA

LCDPIX

2010-04-04T02:07:00.000-07:00

profil facebook et myspace d'un photographe qui a de l'avenir .... ;-)

RAFALE : vidéo des briochins

2010-04-02T11:05:00.000-07:00

vu en live au 22 d'Auron à Bourges eh eh pas mal du tout

RAFALE - DRIVE (clip officiel)
envoyé par RISE_RECORDINGS. - Regardez la dernière sélection musicale.

Script de conversion DTED vers image tiff

2010-03-31T13:37:00.000-07:00

J'ai écrit ce script pour convertir les fichiers DTED nasa en image , le traitement est très lent mais peut importe 13000*6000 en 20min sur un athlon 2200 + ,
ce script a été testé sur debian "testing" à la date du message

# -*- coding: utf-8 -*-
#!/usr/bin/env python
### yoann
### conversion des fichier dted contenu dans un repertoire puis concatenation pour en faire un fichier tiff
### inspiré par un example GDAL (voir licence ci dessous)

###############################################################################
# $Id$
#
# Project: GDAL Python samples
# Purpose: Script to replace specified values from the input raster file
#           with the new ones. May be useful in cases when you don't like
#           value, used for NoData indication and want replace it with other
#           value. Input file remains unchanged, results stored in other file.
# Author:   Andrey Kiselev, dron@remotesensing.org
#
###############################################################################
# Copyright (c) 2003, Andrey Kiselev
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.
###############################################################################

from PIL import Image
import sys
import math

try:
    from osgeo import gdal
    from osgeo.gdalconst import *
    gdal.TermProgress = gdal.TermProgress_nocb
except ImportError:
    import gdal
    from gdalconst import *

try:
    import numpy as Numeric
    Numeric.arrayrange = Numeric.arange
except ImportError:
    import Numeric

try:
    from osgeo import gdal_array as gdalnumeric
except ImportError:
    import gdalnumeric

ny=1200
nx=1200
max_Latitude=0
min_Latitude=90
max_Longitude=0
min_Longitude=90

# usage
# python gdal_3.py *.dt1

## parcourt des fichier DTED pour établir les limites de la matrice résultante

for i in sys.argv[1:]:
    print i
    indataset = gdal.Open( i, GA_ReadOnly )
    print indataset.GetGeoTransform()
    information = indataset.GetGeoTransform()
    Latitude= float(information[3])
    resolution_lati=abs(float(information[5]))
    Latitude = int(Numeric.rint(Latitude))
    Longitude= float(information[0])
    resolution_longi=abs(float(information[1]))
    Longitude = int(Numeric.rint(Longitude))
    if Latitude>max_Latitude:
        max_Latitude=Latitude
    if Latitude
        min_Latitude=Latitude
    if Longitude>max_Longitude:
        max_Longitude=Longitude
    if Longitude
        min_Longitude=Longitude
min_Latitude=min_Latitude-1200*resolution_lati
max_Longitude=max_Longitude+1200*resolution_longi

nb_pixel_Lati = (max_Latitude-min_Latitude)/resolution_lati
nb_pixel_Longi = (max_Longitude-min_Longitude)/resolution_longi

print "nb pixel",nb_pixel_Lati,nb_pixel_Longi

print 'max_Latitude',max_Latitude,'min_Latitude',min_Latitude
print 'max_Longitude',max_Longitude,'min_Longitude',min_Longitude

datas_dted=Numeric.zeros((1200,1200,3),dtype=Numeric.uint8)
scanline_totale=Numeric.zeros((nb_pixel_Lati+1,nb_pixel_Longi),dtype=Numeric.uint32)
max_altitude=0
## parcourt des fichier DTED pour remplir la matrice
for i in sys.argv[1:]:
    indataset = gdal.Open( i, GA_ReadOnly )
    information = indataset.GetGeoTransform()
    Latitude= float(information[3])
    resolution_lati=abs(float(information[5]))
    Latitude = int(Numeric.rint(Latitude))
    Longitude= float(information[0])
    resolution_longi=abs(float(information[1]))
    Longitude = int(Numeric.rint(Longitude))
    index_lati=(max_Latitude-Latitude)*ny
    index_longi=(Longitude-min_Longitude)*nx
    print 'index',index_lati,index_longi
    nom_du_fichier="DTED_LAT_"+str(Latitude)+"_LONG_"+str(Longitude)

    print nom_du_fichier

    for iBand in range(1, indataset.RasterCount + 1):
        inband = indataset.GetRasterBand(iBand)
        for i in range(inband.YSize - 1, -1, -1):
            scanline = inband.ReadAsArray(0, i, inband.XSize, 1, inband.XSize, 1)

            seuil_alt=0

            scanline[0][scanline[0]<=seuil_alt]=0

            if Numeric.max(scanline)>max_altitude:
                max_altitude=Numeric.max(scanline)



            # on supprime systèmatiquement le dernier indice
            scanline_2=Numeric.delete(scanline,-1)
            gradient=scanline_2[1:]-scanline_2[:-1]

            while Numeric.min(gradient)<-500:
                scanline_2[Numeric.argmin(gradient)+1]=scanline_2[Numeric.argmin(gradient)]
                gradient=scanline_2[1:]-scanline_2[:-1]
            # on ajjoute des lignes à gauche et à droite pour le padding en fonction de la longi actuelle
            tmp_ligne_deb=Numeric.zeros((index_longi))
            tmp_ligne_fin=Numeric.zeros((nb_pixel_Longi-index_longi-nx))
            scanline_2=Numeric.insert(scanline_2,tmp_ligne_deb,0)
            scanline_2=Numeric.append(scanline_2,tmp_ligne_fin)
            scanline_totale[index_lati+i]=scanline_totale[index_lati+i]+scanline_2
    del indataset
print max_altitude

# on construit une image RVB
scanline_totale_r=Numeric.zeros((nb_pixel_Lati+1,nb_pixel_Longi),dtype=Numeric.uint8)
scanline_totale_v=Numeric.zeros((nb_pixel_Lati+1,nb_pixel_Longi),dtype=Numeric.uint8)
scanline_totale_b=Numeric.zeros((nb_pixel_Lati+1,nb_pixel_Longi),dtype=Numeric.uint8)

indices=scanline_totale[(scanline_totale>0)]
## gestion de l'altimétrie (variation de couleur)
scanline_totale_r[scanline_totale>0]=150
scanline_totale_v[scanline_totale>0]=Numeric.asarray(scanline_totale[scanline_totale>0]*(150-75)/max_altitude+75,dtype=Numeric.uint8)
scanline_totale_b[scanline_totale>0]=Numeric.asarray(scanline_totale[scanline_totale>0]*(150)/max_altitude,dtype=Numeric.uint8)
scanline_totale_r[scanline_totale==0]=0
scanline_totale_v[scanline_totale==0]=0
scanline_totale_b[scanline_totale==0]=170
scanline_totale_r[scanline_totale<0]=0
scanline_totale_v[scanline_totale<0]=255
scanline_totale_b[scanline_totale<0]=0

# sauvegarde
donnee_dted=Numeric.dstack((scanline_totale_r,scanline_totale_v,scanline_totale_b))
image=Image.fromarray(donnee_dted)
image.save("sortie" + ".tif", "TIFF")

Module carte "in progress"

2010-03-31T12:47:00.000-07:00

De dted

LO FC 2 est dispo !!!!!

2010-03-26T23:25:00.000-07:00

comme c'est zoli !!!!!

FONCTIONS PREVUES POUR L'AFFICHAGE DE LA CARTE

2010-03-24T14:05:00.000-07:00

La carte est fonctionnelle et affiche la carte vectorielle 8 niveau

les fonctions suivantes sont prévues pour le module d'affichage des cartes :

calcul de "bullseye"
calcul de "bearing / angle"
affichage d'annotation sur la carte
Affichage des bases
affichage des pistes (symboles Mil - Std like)

Récepteur UDP

2010-03-20T09:49:00.001-07:00

ci joint le code du récepteur UDP, pas d'astuce particulières sauf en ce qui concerne le lancement de plusieurs récepteurs sur un seul PC

import socket

UDP_IP="192.168.0.11"
UDP_PORT=8123

sock = socket.socket( socket.AF_INET, # Internet
                      socket.SOCK_DGRAM ) # UDP
# permet de lancer plusieurs abonné sur un meme PC
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind( (UDP_IP,UDP_PORT) )

while True:
    data, addr = sock.recvfrom( 1024 )
    print "Message :", data

Vectorisation de la carte DTED

2010-03-20T08:30:00.000-07:00

pour l'affichage futur via cairo, j'ai vectorisé la carte au format svg en utilisant inkscape :

pas de problème lors des zooms
gestion accélérée par cairo

elle ne pèse plus que 300ko !!!

la lecture du fichier sera réalisée par rsvg , le rendu par cairo, un exemple est disponible en suivant le lien ci dessous
http://www.cairographics.org/pyrsvg/

De dted

les étapes sont :

generation au format tiff :
redimensionnement de l'image (9 environ) pour passer en 2000x1000
filtrage sous gimp (antiparasite filtre récursif de rayon 7) permettant de faciliter la vectorisation (surtout l'alléger)

De dted

puis enfin utilisez inkskape pour vectoriser le résultat (couleur , 16 passes)

De dted

convertisseur TCP pour diffusion vers l'UDP

2010-03-13T09:58:00.000-08:00

Le code ci dessous permet l'interface avec lock et le transfert sur le réseau des trames UDP en broadcast...

elle fonctionne au rythme des envois de lock on

# -*- coding: cp1252 -*-

import threading
import math
import os
import string
import re
import time
import socket
import sys
import csv
import SocketServer
import struct

###socket
socket_udp=None
###hosts pour diffusion
EMETTEUR_UDP_host = None
###port pour diffusion
EMETTEUR_UDP_port = None

'''
HANDLER TCP, prend en charge l'initialisation du dialogue avec lock on , arn... + la prise en compte des messages pour diffusion sur le réseau en UDP

'''
class MyTCPHandler(SocketServer.BaseRequestHandler):
        def handle(self):
                while 1:
            # reception des information de lock on
                        self.data = self.request.recv(2048).strip()
            # demande d'init de lock on
                        if self.data == "Arn.Inicio:0:1:2:" :
                                self.request.send("Arn.Vivo:\n")
            # reponse suite a la demande d'init
                        elif self.data == "Arn.Vivo:" :
                                print 'connexion de lockon'
                                self.request.send("Arn.Vivo:\n")
                        else :
                                heure=time.time()
                # on envoie simplement les trames sur le réseau

                                socket_udp.sendto(self.data, (EMETTEUR_UDP_host, EMETTEUR_UDP_port))
                        if len(self.data)==0:
                                return

# Main program
def main():
        global socket_udp
        global EMETTEUR_UDP_host
        global EMETTEUR_UDP_port

    # valeur d'initialisation
        SERVEUR_TCP_host = "localhost"
        SERVEUR_TCP_port = 8092
        EMETTEUR_UDP_host = '192.168.0.255'
        EMETTEUR_UDP_port = 8123

        print 'Application de routage des informations lock on UNCAST --> BROADCAST'
        flags = sys.argv[1:]
        if len(flags)>0:
                SERVEUR_TCP_ad=flags[0]
                SERVEUR_TCP_port=int(flags[1])
                EMETTEUR_UDP_host=flags[2]
                EMETTEUR_UDP_port=int(flags[3])

        print '############ CONFIGURATION DE L EMETTEUR UDP VERS LE RESEAUX ############'
        print '############ host : ',EMETTEUR_UDP_host
        print '############ port : ',EMETTEUR_UDP_port
    # creation des sockets UDP
        socket_udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        socket_udp.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
    # creation du serveur TCP

        print '############ OUVERTURE DU SERVEUR TCP POUR LOCKON            ############'
        print '############ host : ',SERVEUR_TCP_host
        print '############ port : ',SERVEUR_TCP_port
        serveur_tcp = SocketServer.TCPServer((SERVEUR_TCP_host, SERVEUR_TCP_port), MyTCPHandler)
        serveur_tcp.serve_forever()


main()

SHAKAPONK : homage au clip de RHCP (give it away) et en plus ça réveille !!!!

2010-03-13T03:10:00.000-08:00

Shaka Ponk - How we kill stars
envoyé par totoutard. - Regardez la dernière sélection musicale.

dommage pour les victoires de la musique ........

Carte de la CRIMEE, Fin de la conversion de la carte DTED

2010-03-12T12:33:00.000-08:00

la carte est convertie au format jpeg , reste à placer les aéroport et les indication qui vont bien , et bien sur l'afficher

version "brut de fonderie", remarquez les erreurs du DTED (faut pas se plaindre c'est gratuit merci la NASA :-) )

De dted

version avec correction des erreurs dans le DTED (algo simple)

De dted

Avancement Visu déportées pour LOCK ON

2010-03-11T10:51:00.000-08:00

conformément à l'architecture décrite précédemment les fonctions suivante sont prévues :

affichage des fonctions moteurs et commande --> reprise du proto
affichage MPCD + commande --> reprise du proto
affichage TEWS + commande --> reprise du proto
affichage VSD --> attente lock on FC2
affichage de la carte avec avion du joueur + autres objets AWACS / F15/ A10

affichage d'un bullseye et calculs qui s'en suive

actuellement je récupère la crimée à partir du site EARTH EXPLORER (US GS)
les fichiers récupérés sont au format DTED 1 et sont convertis pour affichage

petite vidéo Black Shark

2010-03-09T13:55:00.001-08:00

Modification de l'architecture

2010-03-07T12:05:00.000-08:00

suite au différents problèmes rencontrés tant avec les scripts lua et les débits j'ai choisi de modifier l'architecture en tenant compte des contraintes suivantes :

chaque application correspond à une fonction, par exemple le MPCD devient une application spécifique
il est possible d'exécuter plusieurs fonctions sur un PC, et de répartir les fonctions
le PC LOCK devient totalement serveur

en terme de modification cela n'est pas anodin, toute l'architecure est à revoir, mais je considère que la version actuelle est un prototype fonctionnel,

l'architecture visée est la suivante :

les grands choix sont

architecture UDP multicast pour la distribution des information (voir peut être corba)
architecture TCP pour les envois vers le PC LOCK ON

LOCK ON : vidéo de FC 2 !!

2010-03-07T10:45:00.000-08:00

FC 2 ne saurait tarder commme l'indique ces différentes vidéos de l'entraînement sur A-10/F-15/Su-25 ,

la balistique des obus est modifiée, et l'effet des tracante est pas mal rendu

reste à voir la date de sortie .

Petite vidéo sympa de Nine inch nails

2010-03-03T11:47:00.000-08:00

montage réalisé par un prof , superbe et adaptée à la musique

LOCK ON : Radar

2010-03-01T13:11:00.000-08:00

le mode TWS pose des problèmes car aucune informations n'est alors transmise par lock on (la question est posée sur le forum ED sans réponse pour l'instant http://forums.eagle.ru/showthread.php?t=50496 )

si pas de réponse alors la solution envisagée pour l'émulation du radar en mode TWS est la suivantes :

transmission de l'intégralité des cibles de type avions hélico au serveur
filtrage en fonction des paramètres suivants :

affichage si en mode TWS uniquement
affichage en fonction de l'azimut/site de l'antenne F15
affichage en fonction de la distance de la cible

si cela pose un problème de charge réseau, il faudra envisager de réduire la récurence d'envois ou de filtrer en distance
on verra bien

Emilie Simon

2010-02-28T09:35:00.001-08:00

Ca envoie copieux .........

2010-02-27T09:22:00.000-08:00

LOCK ON : l'interface fonctionne nickel

2010-02-27T08:51:00.000-08:00

Plus de problèmes réseau !! quelques soucis avec le radar car lock on ne semble pas délivrer d'information en mode TWS

Chris Cornell , tous simplement impressionnant :-o

2010-02-27T08:47:00.001-08:00

LOCK ON : finalisation de l'interface sous glade

2010-02-17T11:36:00.000-08:00

voila, l'interface est fonctionnelle et tourne bien avec lock on hors partie réseau

reste :

voir pourquoi en reseau cela lag (pb de config / routeur ?)
à ajouter des informations concernant l'avionique dans la place qu'il reste

altitude baro
altitude radar
vitesse

LOCK ON : vidéo

2010-02-16T09:52:00.001-08:00

remise en ligne de ma deuxième vidéo sur dailymotion

Clip Lock On
envoyé par yoannq45. - Plus de jeux vidéo !

LOCK ON : AMELIORATION DU RENDU VISUEL

2010-02-10T13:30:00.000-08:00

changement des images et modifications sous glade afin d'améliorer le rendu, il est à noter que sous glade
les widgets sont organisé de la façon suivante
- Drawing area en haut
- image
- bouton en bas

voila ce que cela donne :

De LE BLOG DE YOANN

LOCK ON : PROJET DE COCKPIT , le MPCD fonctionne

2010-01-24T09:18:00.000-08:00

La liaison entre lock on et mon interface est fonctionnelle !!!!
la partie affichage MPCD fonctionne, petite copie d'écran

le seul problèmes est un délais de mise à jour des emports (requête sur les emports toutes les 300ms et il y'en a 11)

prochaine étape, récupérer les informations du TEWS pour affichage

LOCK ON : PROJET DE COCKPIT point au 21-01-10

2010-01-21T12:07:00.000-08:00

le projet avance (lentement) je commence à maitriser l'aspect graphique mais je n'ai pas trop le temps d'avancer sur le sujet , une petite copie d'écran pour montrer la partie MFD

LOCK ON, gestion des projections

2010-01-12T12:54:00.000-08:00

quelques lien donné par YODA sur les changements de repere et la projection réalisée dans lock on

http://forums.eagle.ru/showthread.php?t=44427
http://forums.eagle.ru/showpost.php?p=53829&postcount=7
http://forums.eagle.ru/showthread.php?t=34937&highlight=Curvature
http://forums.eagle.ru/showthread.php?t=34937&highlight=Curvature

afficher des trucs dans les layout , il faut utiliser cr = widgets['layout3'].bin_window.cairo_create() sinon cela ne fait pas grand chose

LOCK ON : PROJET DE COCKPIT partie 1

2010-01-03T13:29:00.000-08:00

petits pièges :
- lock on émet constamment le temps scénario
- il faudra faire un thread de réception

gestion des threads avec gtk
http://forum.hardware.fr/hfr/Programmation/Python/pygtk-thread-rafraichissement-sujet_99872_1.htm
http://faq.pygtk.org/index.py?req=show&file=faq20.006.htp
image dans le bouton
http://ubuntuforums.org/showthread.php?t=439954

commande="Arn.Resp:0=129:1=31\n" attention les commandes analogique sont à donner avec X-500

utiliser une eventbox pour le changement de couleut d'un label
cairo
http://www.tortall.net/mu/wiki/PyGTKCairoTutorial
dessin d'une image en utilisant cairo
http://stackoverflow.com/questions/775528/drawing-a-pixbuf-onto-a-drawing-area-using-pygtk-and-glade

exemple pour utiliser cairo http://zetcode.com/tutorials/pygtktutorial/drawingII/

A tester :
- masque en utilisant une image
- zone de détection ?

transparence
http://faq.pygtk.org/index.py?req=show&file=faq08.013.htp

LOCK ON : édition vidéo

2010-01-01T07:32:00.000-08:00

pour la réalisation de vidéo sur lock on

remplacer avimaker.dll http://www.fichier-dll.fr/avimaker.dll,6440
Utiliser l'encodeur x264vfw de très bonne qualité
1024x768 sinon c'est une galère (même sur un E8500@3.16ghz)

how to pour l'édition des tracks
http://flankertraining.com/lomac/Making_Tracks.html#back

LOCK ON Problèmes graphiques

2010-01-01T07:12:00.000-08:00

Ci dessous quelques liens intéressants pour la résolution de problèmes graphique sur lock on

Nuage pas beau
http://www.checksix-forums.com/showthread.php?t=154257&highlight=nuages&page=2
&
http://www.escadrille-kobra.fr/article/article.php?T=1222629946

plantage si la densité des nuages est trop forte
http://forums.eagle.ru/showthread.php?t=9020&page=2 mais en fait il faudra rester sur moyen au niveau de l'eau

Meilleurs Voeux 2010!

2010-01-01T07:03:00.001-08:00

NINE INCH NAILS, Another Version of the Truth: The Gift

2009-12-31T09:52:00.000-08:00

Nine Inch Nails / Trent Reznor a mis en ligne sous différents format (DVD / vidéo HD et bientôt BluRay) des films des concerts "Lights In The Sky Tour 2008" de Portland, Sacramento et Victoria gratuitement !!!
Les masters ont été montés par des fans, 12 personnes volontaires calée en montage vidéo !
le résultat est téléchargeable à l'adresse suivante : http://thisoneisonus.org/node/34
il est a noter que NIN avait déjà mis en ligne "The SLIP" en FLAC haute qualité et des masters (piste séparées) pour favoriser les remix pas des volontaires (mis en ligne ensuite)
après plusieurs heure de télé-chargement, le resultat est de bonne qualité (même en DVD), je regrette encore plus d'avoir manqué leur concert à Paris
le trailer est visible sur youtube

LOCK ON, contribution

2009-12-31T09:22:00.000-08:00

J'ai réalisé une note pour la BAF concernant l'évitement des missiles dans le jeux
cette note reprend quelques techniques déjà décrites par mitor74 (voir les références à la fin ) : note

De divers

LOCK ON, j'ai rejoint la BAF

2009-12-31T08:52:00.000-08:00

Après une longue hésitation :-) je me suis décidé a postuler dans une escadrille virtuelle, j'ai donc fait une demande pour intégrer la =BAF= alias la "Boulet Air Force" . On vole toutes les semaines les lundi et jeudi soir sur LOCK ON Flaming cliff (1.12a) à partir de 21h.

http://www.zedroopy.net/

DELTA3D : essais de réalisation 3D

2009-12-31T02:55:00.001-08:00

J'ai récemment entrepris de réaliser des essais avec delta 3D sous LINUX, ce fut "sportif" car il fallu dans un premier temps compiler delta3D qui nécessite la compilation de pas mal de librairie qui ne sont pas présentes sur Debian.
La page suivante donne la procédure à réaliser
http://sourceforge.net/apps/mediawiki/delta3d/index.php?title=Debian_Testing_Edition

quelques conseils

compiler l'ensemble en étant utilisateur lambda (utiliser CMAKE) pour ne pas tous casser sur la debian, utiliser un environnement de travail
installer la dernière version d'openscenegraph car la version livrée avec debian est buggée
utiliser les dépendances mises à disposition sur le site delta3D
être patient (1 journée en gros pour la création d'un environnement)

Pour mes tests je voulais afficher un terrain en 3D avec des modèles d'avion 3D

Terrain :
j'ai utilisé des DTED issus d'un site gouvernemental US (USGS) :
http://edcsns17.cr.usgs.gov/EarthExplorer/
ce site est bien organisé et permet la selection de différents format et notamment DTED, sélectionner pour cela "digital elevation" puis "SRTM", le reste est assez simple a utiliser
pour la france on obtient du DTED 1 pour les USA DTED 2

Avion :
j'ai utilisé les modèles 3D disponible sur Google (http://sketchup.google.com/)

quelques lignes de C++ plus tard voilà le résultat :

Rq : le fait que cela soit en noir et blanc est voulu (look & feel IR)

Ensuite j'ai testé quelques traitement graphique directement dans la carte graphique (shader) en utilisant le mode prérender de DELTA 3D,

le principe est :

on crée une caméra filmant la scène (l'avion + le terrain)
on récupère l'image
on crée une deuxième caméra , filmant un plan
on utilise l'image pour la texture du plan
on traite le plan en utilisant le shader 3D (GLSL)

cela donne :

en conclusion :

pour ce genre de traitement, il est nécessaire d'avoir une bonne carte graphique (type Geforce 7600Gt) car le shader bouffe pas mal de ressource toutefois on pourrait envisager de faire du traitement d'image haute performance en utilisant cette fonction, avec du matériel bas coût

LOCK ON : VFAT 2009

2009-12-04T12:10:00.000-08:00

pour savoir ce que l'on peut faire avec une jeux comme lock on et des pilotes virtuel rendez vous sur le site http://www.virtual-airshows.com/english/vfattv

Suite des manips

2008-11-09T13:52:00.001-08:00

Pour le traitement, je renonce à utiliser PIL qui finalement est très limitée, je m'oriente donc vers la librairie open_cv de intel qui dispose d'une api sous python (SWIG). Cette librairie intègre d'origine des algorithmes de flot optique (lucas kanadi et 2 autres), je ferais donc mes essais avec cette librairie.
Pour info open_cv ne date pas d'hier et pose des soucis d'utilisation sous debian, notamment elle demande une fonction "img_read" qui n'existe plus dans ffmpeg, la manip pour s'en sortir est décrite à l'addresse suivante :
http://wiki.nuigroup.com/Installing_Multitouch_and_fixing_OpenCV_on_Debian_Lenny
un bug a été signalé, à suivre

Essais d'acquisition vidéo sous linux python

2008-10-21T11:01:00.000-07:00

Objectifs :
réaliser un système de détection d'intrusion vidéo fournissant les fonctions suivantes :

détection/ estimation de mouvement
enregistrement des images suite à la détection (durée configurable)
envois sur un site ftp des données
envois d'un email suite à la détection

et aussi :

comprendre l'architecture d'acquisition Linux "vidéo for linux 1 "
réaliser un début d'interface video4linux/python via du C

Architecture fonctionnelle :

Réalisation

le matériel d'essais est le suivant :

PC Pentium4 sous linux
une carte d'acquisition ADS Tech Instant TV
une caméra CCIR noir et blanc 352/288 25i/s avec capacités nocturnes (diodes IR)

pour le soft j'ai installé sur le PC (non exhaustive):

une debian testing noyaux 2.6.26 avec drivers V4l pour la carte ADS tech
logiciel de gestion de v4l
suite de dev pour V4l
python 2.5
package PIL (imagerie) pour python
package imagemagick pour python

les premiers essais consiste en :

l'installation de la carte et branchement de la caméra
vérification des drivers (video4linux) et identification des devices
vérification de la chaîne d'acquisition par des logiciels éprouvés (vérification fonctionnelle)

j'utilise pour ces tests les outils suivants (dispo sur debian testing) :

dmesg (vérification de la gestion de la carte par le noyaux linux)
v4l-info
transcode
xawtv

Vérification des drivers (dmesg/v4l-info)

Dans une console, on lance la commande "dmesg|less" et on récupère une sortie du type :

[ 14.307392] saa7133[0]: found at 0000:02:07.0, rev: 240, irq: 16, latency: 64, mmio: 0xfe1ff800
[ 14.307476] saa7133[0]: subsystem: 1421:0350, board: ADS Tech Instant TV (saa7135) [card=58,autodetected]
[ 14.307567] saa7133[0]: board init: gpio is 7f
...
[ 14.860097] tuner' 1-004b: chip found @ 0x96 (saa7133[0])
[ 14.940048] tda829x 1-004b: setting tuner address to 61
[ 15.096045] tda829x 1-004b: type set to tda8290+75
[ 19.348322] saa7133[0]: registered device video0 [v4l2]
[ 19.348425] saa7133[0]: registered device vbi0

ces informations indiques que la carte d'acquisition est bien reconnue (tuner et acquisition) en tant que périphérique /dev/video0 (attention peut être supérieur si plusieurs périphérique sont présents) , on peut donc connecter la caméra et vérifier l'acquisition
V4l-info, cet outil donne plus d'informations sur la carte d'acquisition et ses capacités, notamment sur le codage de couleur exploitable par la carte d'acquisition et les normes TV supportées la partie intéressante (entre autres) est la description des canaux disponibles pour l'acquisition (partie "channel" ) :

channels
VIDIOCGCHAN(0)
channel : 0
name : "Television"
tuners : 1
flags : 0x1 [TUNER]
type : TV
norm : 0
VIDIOCGCHAN(1)
channel : 1
name : "Composite1"
tuners : 0
flags : 0x0 []
type : CAMERA
norm : 0
VIDIOCGCHAN(2)
channel : 2
name : "S-Video"
tuners : 0
flags : 0x0 []
type : CAMERA
norm : 0

cette carte fournit 1 entrée tuner, 1 entrée composite, 1 entrée S-vidéo Y/C (voir wikipédia pour plus d'explication), en gros une caméra Y/C sépare la couleur de la luminance afin de profiter d'une plus grande bande passante --> meilleure qualité, ici on a pas le choix la caméra est NB et la connectique est de type composite (1 coax)

Essais d'acquisition (transcode/xawtv)

Une fois la caméra connectée on peut faire quelques essais, on utilise pour cela l'outil "transcode" qui permet l'acquisition simple d'image issues d'un périphériques. la ligne de commande à utiliser est la suivante :
transcode -i /dev/video0 -g 352x288 -y jpg

Après le lancement cette commande lance l'acquisition et génère des images JPEG à partir de l'acquisition d'image sur le périphérique video0 au format 352*288. Cela fonctionne sans problème à 25hz (fréquence caméra), signifiant que transcode sélectionne automatiquement le canal à utiliser ainsi que la norme ...
xawtv fournit une interface permettant la visualisation en temps réel de la vidéo numérisée par la carte.

attention, si xawtv est lancé sans option, alors il prendra par défaut le périphérique video0 et le canal/norme par défaut, ces paramètres sont modifiables dans l'interface (sauf le périphérique fixé lors du lancement par l'option "-c /dev/videoX" voir dmesg)

Accès à la carte d'acquisition :

L'accès au périphérique d'acquisition sont réalisés par l'api video4linux évidemment si un drivers existe pour le périphérique en question voir http://linux.bytesex.org/v4l2/
cette API existe en C et Perl et un début existe pour Python. Je me suis donc inspiré d'exemple et documenté en python pour réaliser une interface simplifiée pour Video4linux, le fichier en C ci dessous permet cette interfacage (fichier interface_v4l_py.c)

// fichier interface_v4l_py.c
#include ""

#include ""
#include ""
#include ""
#include ""
#include ""
#include ""
#include ""
#include ""
#include ""
#include ""
#include ""

#define VIDEO_DEV "/dev/video0"
#define WIDTH 352
#define HEIGHT 288
#define CHANNEL 1

static int variable_locale=0;

static int fdv;
static unsigned char *framebuf;
static struct video_capability vcap;
static struct video_channel vc;
static struct video_mmap mm;
static int height;
static int width;
// static char video_device[16];
static struct video_mbuf vid_mbuf;

// fonction
// static void rgb_swap(char *mem, int n)
// description
// cette fonction permet l'inversion des couleur bleur et rouge (problème de certaine webcam
// elle n'est pas accessible par python
// E
// mem : pointeur sur des pixels codés RVB
// n : nombre de pixels
// S
// mem : pointeur sur des pixels codés RVB

static void rgb_swap(char *mem, int n)
{
char c;
char *p = mem;
int i = n;

//printf("swap\n");
while (--i) {
c = p[0]; p[0] = p[2]; p[2] = c;
p += 3;
}
}

// fonction
// static PyObject* v4l_initalize_device(PyObject* self, PyObject* args)
// description
// cette fonction permet l'initialisation d'un périphérique vidéo 4 linux,
// elle est accèssible par python
//
// E
// video_device : chaine définissant le device
// channel : numéro du canal (int)
// width : largeur de l'acquisition (int)
// height : hauteur de l'acquisition (int)
// S
// -1 : si échec
// 1 : si OK

static PyObject* v4l_initalize_device(PyObject* self, PyObject* args)
{
char *video_device;
int channel;
if(!PyArg_ParseTuple(args, "siii", &video_device,&channel,&width,&height))
return NULL;
// Init V4l
// printf("DEBUG INTERFACE %s,%d\n",video_device,channel);

fdv = open (video_device, O_RDWR);
if (fdv <= 0){
perror (VIDEO_DEV);
return Py_BuildValue("i",-1);
}
if (ioctl (fdv, VIDIOCGCAP, &vcap) <>
perror ("VIDIOCGCAP");
return Py_BuildValue("i",-1);
}
vc.channel = channel;
vc.norm = VIDEO_MODE_PAL;

if (ioctl(fdv, VIDIOCSCHAN, &vc) <>
perror ("VIDIOCSCHAN");
return Py_BuildValue("i",-1);
}
ioctl(fdv, VIDIOCGMBUF, &vid_mbuf);
framebuf = (unsigned char*)mmap(0, vid_mbuf.size, PROT_READ | PROT_WRITE, MAP_SHARED, fdv, 0);
if ((unsigned char *)-1 == (unsigned char *)framebuf) {
perror ("mmap");
return Py_BuildValue("i",-1);
}

return Py_BuildValue("i", 1);
}

// fonction
// static PyObject* v4l_close_device(PyObject* self, PyObject* args)
// description
// cette fonction permet la fermeture du device et la suppression du map memeoire
// E
// aucune
// S
// 1 : si OK

static PyObject* v4l_close_device(PyObject* self, PyObject* args)
{

// on ferme le device
if (close(fdv))
perror("close(fdv) ");
// on realise l'unmap
if (munmap(framebuf, vid_mbuf.size) != 0)
{
perror("munmap()");
exit(1);
}
framebuf = NULL;

return Py_BuildValue("i", 1);
}

// fonction
// static PyObject* v4l_set_brightness(PyObject* self, PyObject* args)
// description
// permet la modification de la luminance sur le périphérique
// E
// valeur de luminance entre 0 et 100%
// S
// retour de IOCTL : si OK

static PyObject* v4l_set_brightness(PyObject* self, PyObject* args)
{
struct video_picture vpic;
int newbright;

if(!PyArg_ParseTuple(args, "i", &newbright))
return NULL;
variable_locale++;
if (ioctl (fdv, VIDIOCGPICT, &vpic) <>
perror ("grab_bright_set");
return Py_BuildValue("i",-1);
}
vpic.brightness = (unsigned int)newbright * 65536 / 100;
return Py_BuildValue("i", ioctl (fdv, VIDIOCSPICT, &vpic));
}

// fonction
// static PyObject* v4l_set_contrast(PyObject* self, PyObject* args)
// description
// permet la modification du contrast sur le périphérique
// E
// valeur de contraste entre 0 et 100%
// S
// retour de IOCTL : si OK

static PyObject* v4l_set_contrast(PyObject* self, PyObject* args)
{
struct video_picture vpic;
int newcontrast;

if(!PyArg_ParseTuple(args, "i", &newcontrast))
return NULL;
variable_locale++;
if (ioctl (fdv, VIDIOCGPICT, &vpic) <>
perror ("grab_contrast_set");
return Py_BuildValue("i",-1);
}
vpic.contrast = (unsigned int)newcontrast * 65536 / 100;
return Py_BuildValue("i", (int)ioctl (fdv, VIDIOCSPICT, &vpic));
}

// fonction
// static PyObject* v4l_acquisition(PyObject* self, PyObject* args)
// description
// permet l'acquisition d'une image complete
// E
// 1 : inversion des couleurs R/B
// 0 : pas d'inversion
// S
// les pixels en codage RVB

static PyObject* v4l_acquisition(PyObject* self, PyObject* args)
{
int swap;
swap=0;
if(!PyArg_ParseTuple(args, "i", &swap))
return NULL;
mm.frame = 0;
mm.height = height;
mm.width = width;
mm.format = VIDEO_PALETTE_RGB24;
/* Get frame */
if (ioctl(fdv, VIDIOCMCAPTURE, &mm) <>
perror ("VIDIOCMCAPTURE");
return Py_BuildValue("i", -1);
}

/* Wait frame to be completed */
if (ioctl(fdv, VIDIOCSYNC, &mm.frame) <>
perror ("VIDIOCSYNC");
return Py_BuildValue("i", -1);
}
if (swap)
{
rgb_swap (framebuf, width * height);
//printf("swap\n");
}

/*on retourne la valeur de*/
return Py_BuildValue("s#", framebuf, mm.height*mm.width*3);
}

// definition du paquet

static PyMethodDef fonctions[]={
{"v4l_initalize_device" , v4l_initalize_device, METH_VARARGS, "initialise le peripherique"},
{"v4l_set_brightness" , v4l_set_brightness, METH_VARARGS, "definit la luminance"},
{"v4l_set_contrast" , v4l_set_contrast, METH_VARARGS, "definit le contraste"},
{"v4l_acquisition" , v4l_acquisition, METH_VARARGS, "acquisition d une image"},
{"v4l_close_device" , v4l_close_device, METH_VARARGS, "ferme le peripherique"},
{NULL, NULL, 0, NULL}
};

PyMODINIT_FUNC init_interface_v4l(void)
{
PyObject* m;
m = Py_InitModule("_interface_v4l", fonctions);
}

la compilation de ce genre d'interface n'est pas réalisée directement mais elle est assistée par python, pour le compiler il faudra creer un fichier setup.py contenant le code suivant :

#!/usr/bin/python
# -*- coding: cp1252 -*-
# lancer python setup.py build_ext --inplace

from distutils.core import setup, Extension
setup(name="_interface_v4l", version="1.0",ext_modules=[Extension("_interface_v4l", ["interface_v4l_py.c"])])

on lance ensuite la compilation par la commande "python setup.py build_ext --inplace" , un fichier _interface_v4l.so est créé donnant accès a vidéo4linux
maintenant on accède au périphérique via un simple script python

import _interface_v4l
device = "/dev/video0"
channel = 1
swap = 0
_interface_v4l.v4l_initalize_device(device,channel,352,288)
_interface_v4l.v4l_set_brightness(70)
_interface_v4l.v4l_set_contrast(70)

print "P6"
print "352 288"
print "255"
print _interface_v4l.v4l_acquisition(swap)
_interface_v4l.v4l_close_device()

si on lance ce script la sortie créée est un flux de pixel au format PPM
reste donc à réaliser les traitements.........