ENIB LANG-CPP App_01 - Exercice applicatif sur un thème imposé

{} Représentation des images

Nous travaillerons autour la notion d'image (photo...).
Pour ceci vous disposerez d'un programme écrit en Python qui charge des images, leur applique des traitements, les affiche et les sauvegarde.
Vous n'aurez pas à modifier ce programme ; votre travail consistera à compléter une extension écrite en C++ utilisée par ce programme en Python.

Une fois une image extraite du fichier la représentant, nous la manipulerons à l'aide de trois informations : sa largeur (nombre de colonnes), sa hauteur (nombre de lignes) et l'ensemble des octets décrivant ses pixels au format RGB.
Cet ensemble d'octets est un tableau unidimensionnel organisé de la façon suivante :

Chaque pixel est constitué de trois composantes indiquant respectivement la quantité de rouge, de vert et de bleu nécessaire à l'obtention de sa couleur résultante.
- Chaque composante est un octet interprété comme un petit entier permettant de compter de 0 (couleur infiniment sombre) à 255 (couleur très vive).
Chaque ligne est constituée de la suite de ses pixels constitutifs énumérés de gauche à droite.
L'image globale est constituée de la suite de ses lignes constitutives énumérées de haut en bas.

Ainsi, à titre d'illustration, si une image fait 40 lignes de 100 colonnes chacune, alors elle est constituée de 4000 pixels (100*40), soient 12000 octets (3*100*40).
Nous numéroterons ses colonnes de 0 (gauche) à 99 (droite) et ses lignes de 0 (haut) à 39 (bas) :

Le pixel à l'indice 0 est situé en haut à gauche.
- Les octets aux indices 0, 1 et 2 représentent ses composantes rouge, verte et bleue.
Le pixel à l'indice 99 est situé en haut à droite.
- Les octets aux indices 297, 298 et 299 représentent ses composantes rouge, verte et bleue (3*99...).
Le pixel à l'indice 3900 (100*39) est situé en bas à gauche.
- Les octets aux indices 11700, 11701 et 11702 représentent ses composantes rouge, verte et bleue (3*100*39...).
Le pixel à l'indice 3999 (99+100*39) est situé en bas à droite.
- Les octets aux indices 11997, 11998 et 11999 représentent ses composantes rouge, verte et bleue (3*(99+100*39)...).
Le pixel situé à la colonne x et à la ligne y a l'indice x+100*y.
- Les octets aux indices 3*(x+100*y)+0, 3*(x+100*y)+1 et 3*(x+100*y)+2 représentent ses composantes rouge, verte et bleue.

Assurez vous d'avoir bien compris cela avant de poursuivre !

{} Préparation de l'environnement de travail

Créez sur votre poste de travail un répertoire pour cet exercice que vous nommerez à votre convenance.
Tous les fichiers suivants y prendront place

Fichier imageUtils.py✎

Contenu du fichier imageUtils.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#-----------------------------------------------------------------------------

import sys
import os
import platform
import ctypes
import traceback
import time

try:
  import Tkinter # python 2
except:
  import tkinter as Tkinter # python 3

class Record:
  __init__=lambda self, **kw: self.__dict__.update(**kw)
  __repr__=lambda self: repr(self.__dict__)
  __eq__=lambda self, oth: oth is not None and self.__dict__==oth.__dict__
  __getitem__=lambda self, attr: self.__dict__.__getitem__(attr)
  __setitem__=lambda self, attr, value: self.__dict__.__setitem__(attr, value)
  get=lambda self, attr, default=None: self.__dict__.get(attr, default)

class CB:
  def __init__(self, cb, *args, **kw):
    self.cb=cb
    self.args=args
    self.kw=kw
  #
  def __call__(self, *args, **kw):
    return self.cb(self, *args, **kw)

def makeFrame(app, fnct, img1, img2):
  app.fnct=fnct
  app.w1=img1[0]
  app.h1=img1[1]
  app.d1=img1[2]
  pfx=('P6\n%d %d\n255\n'%(app.w1, app.h1)).encode()
  offset=len(pfx)
  app.d=bytearray(offset+len(app.d1))
  for i in range(offset): app.d[i]=pfx[i]
  if img2:
    app.w2=img2[0]
    app.h2=img2[1]
    app.d2=img2[2]
    app.work=lambda a: a.fnct(a.w1, a.h1, a.d1,
                              a.w2, a.h2, a.d2, a.sclValue, a.d)
  else:
    app.w2=0
    app.h2=0
    app.d2=None
    app.work=lambda a: a.fnct(a.w1, a.h1, a.d1, a.sclValue, a.d)
  app.outFile='output_'+fnct.__name__+'.ppm'
  if not Tkinter._default_root: Tkinter.Tk().withdraw()
  app.top=Tkinter.Toplevel()
  app.top.title(app.outFile)
  app.top.wm_protocol('WM_DELETE_WINDOW', CB(quitCmd, app))
  app.top.rowconfigure(0, weight=1)
  app.top.rowconfigure(1, weight=0)
  app.top.columnconfigure(0, weight=1)
  app.photo=Tkinter.PhotoImage(width=app.w1, height=app.h1)
  app.ppmConvert=None
  app.ppm=None
  app.lbl=Tkinter.Label(app.top)
  app.lbl.config(width=app.w1, height=app.h1, anchor='nw', image=app.photo)
  app.lbl.grid(row=0, column=0, sticky='nsew')
  if fnct.__name__=='imgBlend':
    sclMax=100
    app.sclScroll=5
  else:
    sclMax=8
    app.sclScroll=1
  app.scl=Tkinter.Scale(app.top, orient=Tkinter.HORIZONTAL,
                        from_=0, to=sclMax, resolution=1,
                        command=CB(scaleCmd, app))
  app.scl.grid(row=1, column=0, sticky='nsew')
  app.top.minsize(2+app.w1, 4+app.h1+app.scl.winfo_reqheight())
  app.top.bind("<KeyPress-Escape>", CB(quitCmd, app))
  app.top.bind("<KeyPress-q>", CB(quitCmd, app))
  app.top.bind('<ButtonPress-4>', CB(mouseWheelCmd, app))
  app.top.bind('<ButtonPress-5>', CB(mouseWheelCmd, app))
  app.lastMouseWheel=0
  app.sclValue=-1
  app.times=None
  app.timeIdx=0
  app.scl.set(sclMax)
  if app.d2: app.scl.set(0)

def updatePpm(app):
  if app.ppmConvert is None:
    # depending on python/tkinter versions (and bugs), some conversions
    # are required when providing Tkinter.PhotoImage data
    # - python 3 wants bytes() and directly accesses them
    # - python 2 wants utf-8 encoded str() but decodes it to bytes again!
    app.ppmConvert=[] # one of these should work...
    if 0: # memory leak!!!
      app.ppmConvert.append(lambda ppm: app.top.tk._createbytearray(ppm))
    if Tkinter.__name__=='tkinter': # bad utf-8 conversions in python 2
      app.ppmConvert.append(lambda ppm: bytes(ppm))
    app.ppmConvert.append(lambda ppm: ppm.decode('latin-1').encode('utf-8'))
    app.ppmConvert.append(lambda ppm: ppm.decode('latin-1').encode('utf-8') \
                                         .replace(b'\x00', b'\xc0\x80'))
  while app.ppmConvert:
    try:
      ppm=app.ppmConvert[0](app.d)
      # FIXME: some versions of Tkinter.PhotoImage have a memory leak!
      #        (probably in tk._createbytearray)
      #        thus we perform a direct call to Tcl/Tk
      if 0:
        app.photo.config(width=app.w1, height=app.h1,
                         format='ppm', data=ppm)
      else:
        app.top.tk.call(app.photo.name, 'configure',
                        '-width', app.w1, '-height', app.h1,
                        '-format', 'ppm', '-data', ppm)
      break # this conversion was suitable
    except:
      # traceback.print_exc()
      del app.ppmConvert[0] # forget this conversion which was not suitable

def quitCmd(helper, *args, **kw):
  app=helper.args[0]
  sys.stdout.write('Saving `%s\'\n'%app.outFile)
  open(app.outFile, 'wb').write(app.d)
  Tkinter._default_root.quit()

def mouseWheelCmd(helper, evt, *args, **kw):
  app=helper.args[0]
  if evt.serial!=app.lastMouseWheel:
    app.lastMouseWheel=evt.serial
    if evt.num==4:
      app.scl.set(app.sclValue+app.sclScroll)
    elif evt.num==5:
      app.scl.set(app.sclValue-app.sclScroll)

def scaleCmd(helper, sclValue, *args, **kw):
  app=helper.args[0]
  sclValue=int(sclValue)
  if sclValue!=app.sclValue:
    app.sclValue=sclValue
    timeFnct=time.time
    workFnct=app.work
    t0=timeFnct(); workFnct(app); t1=timeFnct()
    if not app.times:
      app.times=[t1-t0]*64
      app.times=(ctypes.c_double*len(app.times))(*app.times)
    app.times[app.timeIdx]=t1-t0
    app.timeIdx=(app.timeIdx+1)%len(app.times)
    sys.stdout.write('average %s() time: %g\n'%
                     (app.fnct.__name__, sum(app.times)/len(app.times)))
    updatePpm(app)

def imgBlend(w1, h1, d1, w2, h2, d2, k, d):
  offset=len(d)-3*w1*h1
  ratio=k/100.0
  compRatio=1.0-ratio
  for y1 in range(h1):
    for x1 in range(w1):
      x2=int(x1*w2/w1)
      y2=int(y1*h2/h1)
      i1=x1+y1*w1
      i2=x2+y2*w2
      d[offset+3*i1+0]=int(d1[3*i1+0]*compRatio+d2[3*i2+0]*ratio)
      d[offset+3*i1+1]=int(d1[3*i1+1]*compRatio+d2[3*i2+1]*ratio)
      d[offset+3*i1+2]=int(d1[3*i1+2]*compRatio+d2[3*i2+2]*ratio)

def imgReveal(w1, h1, d1, k, d):
  offset=len(d)-3*w1*h1
  shift=8-k
  for i in range(w1*h1):
    d[offset+3*i+0]=(d1[3*i+0]<<shift)&0x00FF
    d[offset+3*i+1]=(d1[3*i+1]<<shift)&0x00FF
    d[offset+3*i+2]=(d1[3*i+2]<<shift)&0x00FF

def imgHide(w1, h1, d1, w2, h2, d2, k, d):
  offset=len(d)-3*w1*h1
  shift=8-k
  mask=(~0)<<k
  for y1 in range(h1):
    for x1 in range(w1):
      x2=int(x1*w2/w1)
      y2=int(y1*h2/h1)
      i1=x1+y1*w1
      i2=x2+y2*w2
      d[offset+3*i1+0]=((d1[3*i1+0]&mask)|(d2[3*i2+0]>>shift))&0x00FF
      d[offset+3*i1+1]=((d1[3*i1+1]&mask)|(d2[3*i2+1]>>shift))&0x00FF
      d[offset+3*i1+2]=((d1[3*i1+2]&mask)|(d2[3*i2+2]>>shift))&0x00FF

def loadPpm(fileName):
  try:
    input=open(fileName, 'rb')
    words=[]
    while len(words)<4:
      words+=input.readline().split(b'#')[0].split()
    if len(words)!=4 or words[0]!=b'P6' or words[3]!=b'255': return None
    (w,h)=(int(words[1]),int(words[2]))
    nb=3*w*h
    d=bytearray(input.read(nb))
    if len(d)!=nb: return None
    return (w, h, d)
  except:
    # traceback.print_exc()
    return None

def main():
  app=Record()
  if len(sys.argv)>1:
    fnct=sys.argv[1]
    if fnct in ['blend', 'reveal', 'hide']:
      fnct='img%s%s'%(fnct[0].upper(),fnct[1:])
      fnct=getattr(sys.modules[__name__], fnct)
      expectedArgs=3 if fnct.__name__=='imgReveal' else 4
      if len(sys.argv)==expectedArgs:
        img1=loadPpm(sys.argv[2])
        if not img1:
          sys.stderr.write('\nCannot open image `%s\'\n'%sys.argv[2])
          sys.exit(1)
        if expectedArgs==4:
          img2=loadPpm(sys.argv[3])
          if not img2:
            sys.stderr.write('\nCannot open image `%s\'\n'%sys.argv[3])
            sys.exit(1)
        else:
          img2=None
        makeFrame(app, fnct, img1, img2)
  if app.get('top') is not None:
    Tkinter._default_root.mainloop() 
  else:
    sys.stderr.write('\n')
    sys.stderr.write('usage: %s blend image1 image2\n'%sys.argv[0])
    sys.stderr.write('       %s reveal image\n'%sys.argv[0])
    sys.stderr.write('       %s hide image1 image2\n'%sys.argv[0])
    sys.stderr.write('\n')

def tryToLoadNativeFunctions():
  try:
    dirName=os.path.dirname(sys.modules[__name__].__file__)
    if not dirName: dirName=os.path.curdir
    libName='NativeImageUtils'
    if platform.system().startswith('Windows'):
      libName='%s.dll'%libName
    elif platform.system().startswith('Darwin'):
      libName='lib%s.dylib'%libName
    else:
      libName='lib%s.so'%libName
    path=os.path.join(dirName, libName)
    ntvLib=ctypes.CDLL(os.path.abspath(path))
    ntvHello=ntvLib['hello']
    ntvHello.restype=ctypes.c_int
    ntvHello.argtypes=[ctypes.c_char_p] # msg
    sys.stdout.write('native hello() returned: %d\n'%
                     ntvHello(b'native code is accessible!'))
    try:
      ntvImgBlend=ntvLib['imgBlend']
      ntvImgBlend.restype=None
      ntvImgBlend.argtypes=[ctypes.c_int,    # w1
                            ctypes.c_int,    # h1
                            ctypes.c_void_p, # d1
                            ctypes.c_int,    # w2
                            ctypes.c_int,    # h2
                            ctypes.c_void_p, # d2
                            ctypes.c_int,    # k
                            ctypes.c_void_p] # d
      def imgBlend(w1, h1, d1, w2, h2, d2, k, d):
        nb1=3*w1*h1
        nb2=3*w2*h2
        ntvImgBlend(w1, h1, (ctypes.c_uint8*nb1).from_buffer(d1),
                    w2, h2, (ctypes.c_uint8*nb2).from_buffer(d2),
                    k, (ctypes.c_uint8*nb1).from_buffer(d, len(d)-nb1))
      setattr(sys.modules[__name__], 'imgBlend', imgBlend)
      sys.stdout.write('native version of imgBlend() made available\n')
    except:
      #traceback.print_exc()
      pass
    try:
      ntvImgReveal=ntvLib['imgReveal']
      ntvImgReveal.restype=None
      ntvImgReveal.argtypes=[ctypes.c_int,    # w1
                             ctypes.c_int,    # h1
                             ctypes.c_void_p, # d1
                             ctypes.c_int,    # k
                             ctypes.c_void_p] # d
      def imgReveal(w1, h1, d1, k, d):
        nb1=3*w1*h1
        ntvImgReveal(w1, h1, (ctypes.c_uint8*nb1).from_buffer(d1),
                     k, (ctypes.c_uint8*nb1).from_buffer(d, len(d)-nb1))
      setattr(sys.modules[__name__], 'imgReveal', imgReveal)
      sys.stdout.write('native version of imgReveal() made available\n')
    except:
      #traceback.print_exc()
      pass
    try:
      ntvImgHide=ntvLib['imgHide']
      ntvImgHide.restype=None
      ntvImgHide.argtypes=[ctypes.c_int,    # w1
                           ctypes.c_int,    # h1
                           ctypes.c_void_p, # d1
                           ctypes.c_int,    # w2
                           ctypes.c_int,    # h2
                           ctypes.c_void_p, # d2
                           ctypes.c_int,    # k
                           ctypes.c_void_p] # d
      def imgHide(w1, h1, d1, w2, h2, d2, k, d):
        nb1=3*w1*h1
        nb2=3*w2*h2
        ntvImgHide(w1, h1, (ctypes.c_uint8*nb1).from_buffer(d1),
                   w2, h2, (ctypes.c_uint8*nb2).from_buffer(d2),
                   k, (ctypes.c_uint8*nb1).from_buffer(d, len(d)-nb1))
      setattr(sys.modules[__name__], 'imgHide', imgHide)
      sys.stdout.write('native version of imgHide() made available\n')
    except:
      #traceback.print_exc()
      pass
  except:
    #traceback.print_exc()
    pass

if __name__=='__main__':
  tryToLoadNativeFunctions()
  main()

#-----------------------------------------------------------------------------

Fichier GNUmakefile✎

Contenu du fichier GNUmakefile

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# this GNU-makefile relies on the GCC toolchain
# nb: on Windows, the Mingw-w64 package provides the mingw32-make.exe command
#     ( see https://web.enib.fr/~harrouet/dev_tools/#windows.mingw )

#~~~~ control global settings ~~~~
# make opt=2 --> enable optimisation, then disable debug, but keep symbols
# make opt=1 --> enable optimisation, then disable debug
# make opt=0 --> disable optimisation, then enable debug
opt=0
# make clang=1 --> use clang/clang++, not gcc/g++
# make clang=0 --> use gcc/g++, not clang/clang++
clang=0
# make wasm=1 --> target webassembly rather than the native platform
# make wasm=0 --> target the native platform rather than webassembly
wasm=0

#~~~~ build library or programs ~~~~
# if LIB_TARGET is provided, this library will be built (with its
# platform-specific name), otherwise ${EXE_PREFIX}* programs will be built
LIB_TARGET=NativeImageUtils
EXE_PREFIX=prog

#~~~~ detect operating system ~~~~
ifneq (${OS},Windows_NT)
  ifneq (,${findstring Ubuntu,${shell lsb_release -i 2>/dev/null}})
    OS:=Ubuntu
  else ifneq (,${findstring Raspbian,${shell lsb_release -i 2>/dev/null}})
    # Standard distribution for Raspberry-Pi
    OS:=Raspbian
  else
    OS:=${strip ${shell uname -s}}
  endif
  ifneq (,${findstring Microsoft,${shell cat /proc/version 2>/dev/null}})
    # Windows-Subsystem-for-Linux
    OS:=${OS}_WSL
  endif
endif

#~~~~ adjust project-specific settings ~~~~
CPPFLAGS=
# CPPFLAGS+=-I header/path
LDFLAGS=
# LDFLAGS+=-L library/path -Wl,-rpath,library/path -l library_name
CFLAGS=
CXXFLAGS=
BINFLAGS=
ifneq (,${findstring Windows_NT,${OS}})
  # nothing special for now
else
  ifneq (,${strip ${LIB_TARGET}})
    BINFLAGS+=-fPIC
  endif
  ifneq (,${findstring Darwin,${OS}})
    # nothing special for now
  else
    ifneq (,${findstring Ubuntu,${OS}})
      # sanitizer sometimes requires gold-linker on Ubuntu
      LDFLAGS+=-fuse-ld=gold
    else ifneq (,${findstring Raspbian,${OS}})
      # some warnings may appear when mixing g++-6 and g++-7 on Raspbian
      CXXFLAGS+=-Wno-psabi
    else
      # nothing special for now
    endif
  endif
endif

#~~~~ adjust platform-specific features (Posix/Windows/Emscripten...) ~~~~
ifneq (,${findstring Windows_NT,${OS}})
  LIB_PREFIX=
  LIB_SUFFIX=.dll
  EXE_SUFFIX=.exe
  SKIP_LINE=echo.
  REMOVE=del /q
else
  LIB_PREFIX=lib
  ifneq (,${findstring Darwin,${OS}})
    LIB_SUFFIX=.dylib
  else
    LIB_SUFFIX=.so
  endif
  EXE_SUFFIX=
  SKIP_LINE=echo
  REMOVE=rm -rf
endif
ifeq (${strip ${wasm}},1)
  LIB_PREFIX:=lib
  LIB_SUFFIX:=.bc
  EXE_SUFFIX:=.html
endif

#~~~~ deduce file names ~~~~
ifneq (,${strip ${LIB_TARGET}})
  LIB_TARGET:=${LIB_PREFIX}${strip ${LIB_TARGET}}${LIB_SUFFIX}
  MAIN_C_FILES=
  MAIN_CXX_FILES=
else
  LIB_TARGET:=
  MAIN_C_FILES=${wildcard ${strip ${EXE_PREFIX}}*.c}
  MAIN_CXX_FILES=${wildcard ${strip ${EXE_PREFIX}}*.cpp}
endif
COMMON_C_FILES=${filter-out ${MAIN_C_FILES},${wildcard *.c}}
COMMON_CXX_FILES=${filter-out ${MAIN_CXX_FILES},${wildcard *.cpp}}
#
MAIN_OBJECT_FILES=${sort ${patsubst %.c,%.o,${MAIN_C_FILES}} \
                         ${patsubst %.cpp,%.o,${MAIN_CXX_FILES}}}
COMMON_OBJECT_FILES=${sort ${patsubst %.c,%.o,${COMMON_C_FILES}} \
                           ${patsubst %.cpp,%.o,${COMMON_CXX_FILES}}}
OBJECT_FILES=${MAIN_OBJECT_FILES} ${COMMON_OBJECT_FILES}
DEPEND_FILES=${patsubst %.o,%.d,${OBJECT_FILES}}
EXE_FILES=${sort ${patsubst %.c,%${EXE_SUFFIX},${MAIN_C_FILES}} \
                 ${patsubst %.cpp,%${EXE_SUFFIX},${MAIN_CXX_FILES}}}
#
GENERATED_FILES=${DEPEND_FILES} ${OBJECT_FILES} ${LIB_TARGET} ${EXE_FILES}
ifneq (,${findstring Darwin,${OS}})
  GENERATED_FILES+=${wildcard *.dSYM}
endif
ifeq (${strip ${wasm}},1)
  GENERATED_FILES+=${patsubst %.html,%.js,${EXE_FILES}}
  GENERATED_FILES+=${patsubst %.html,%.html.mem,${EXE_FILES}}
  GENERATED_FILES+=${patsubst %.html,%.wasm,${EXE_FILES}}
  GENERATED_FILES+=${patsubst %.html,%.wast,${EXE_FILES}}
endif
GENERATED_FILES+=${wildcard output_* *~}

#~~~~ compiler/linker settings ~~~~
CPPFLAGS+=-MMD -pedantic -Wall -Wextra -Wconversion -Wno-sign-conversion
CPPFLAGS+=-Wno-unused -Wno-unused-parameter
CPPFLAGS+=-Werror -Wfatal-errors
CFLAGS+=-std=c99 -Wc++-compat -Wwrite-strings -Wold-style-definition -Wvla
CXXFLAGS+=-std=c++17 -Wno-missing-braces
LDFLAGS+=
BINFLAGS+=
ifeq (${strip ${wasm}},1)
  CC=emcc
  CXX=em++
  CPPFLAGS+=-Wno-dollar-in-identifier-extension
  LDFLAGS+=-s ALLOW_MEMORY_GROWTH=1
else ifeq (${strip ${clang}},1)
  CC=clang
  CXX=clang++
else
  CC=gcc
  CXX=g++
endif
#
ifneq (,${strip ${MAIN_CXX_FILES} ${COMMON_CXX_FILES}})
  # force c++ link if there is at least one c++ source file
  LD:=${CXX}
else
  LD:=${CC}
endif

#~~~~ debug/optimisation settings ~~~~
ifneq (${strip ${opt}},0)
  CPPFLAGS+=-DNDEBUG
  BINFLAGS+=-O3 -ffast-math
  # BINFLAGS+=-fopt-info-vec-optimized
  ifneq (${strip ${wasm}},1)
    BINFLAGS+=-march=native
  endif
  ifeq (${strip ${opt}},2)
    # optimise but keep symbols for profiling
    BINFLAGS+=-g -fno-omit-frame-pointer
  else
    BINFLAGS+=-fomit-frame-pointer
  endif
else
  CPPFLAGS+=-UNDEBUG
  BINFLAGS+=-g -O0
  ifeq (${strip ${wasm}},1)
    # sanitizer is not available yet with Emscripten
  else ifneq (,${findstring Windows_NT,${OS}})
    # sanitizer is not available yet on Windows
  else
    # BINFLAGS+=-fsanitize=address,undefined
    ifneq (,${findstring Raspbian,${OS}})
      # dynamic sanitizer libraries may not be found on Raspbian
      # BINFLAGS+=-static-libasan -static-libubsan
    endif
  endif
endif

#~~~~ main target ~~~~
all : ${EXE_FILES} ${LIB_TARGET}

rebuild : clean all

.SUFFIXES:
.SECONDARY:
.PHONY: all clean rebuild

#~~~~ linker command to produce the library (if any) ~~~~
${LIB_TARGET} : ${COMMON_OBJECT_FILES}
	@echo ==== linking [opt=${opt}] $@ ====
	${LD} -shared -o $@ $^ ${BINFLAGS} ${LDFLAGS}
	@${SKIP_LINE}

#~~~~ linker command to produce the executable files (if any) ~~~~
%${EXE_SUFFIX} : %.o ${COMMON_OBJECT_FILES}
	@echo ==== linking [opt=${opt}] $@ ====
	${LD} -o $@ $^ ${BINFLAGS} ${LDFLAGS}
	@${SKIP_LINE}

#~~~~ compiler command for every source file ~~~~
%.o : %.c
	@echo ==== compiling [opt=${opt}] $< ====
	${CC} -o $@ $< -c ${BINFLAGS} ${CPPFLAGS} ${CFLAGS}
	@${SKIP_LINE}

%.o : %.cpp
	@echo ==== compiling [opt=${opt}] $< ====
	${CXX} -o $@ $< -c ${BINFLAGS} ${CPPFLAGS} ${CXXFLAGS}
	@${SKIP_LINE}

-include ${DEPEND_FILES}

#~~~~ remove generated files ~~~~
clean :
	@echo ==== cleaning ====
	${REMOVE} ${GENERATED_FILES}
	@${SKIP_LINE}

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Fichier pixel.hpp✎

Fichier nativeImageUtils.cpp✎

Contenu du fichier nativeImageUtils.cpp

//----------------------------------------------------------------------------

#if defined _WIN32
# define NATIVE_IMAGE_UTILS_API extern "C" __declspec(dllexport)
#else
# define NATIVE_IMAGE_UTILS_API extern "C"
#endif

#include <cstdint>
#include <iostream>
#include <string>
#include <algorithm>
#include "pixel.hpp"

//----------------------------------------------------------------------------
// Minimal function called from Python
//----------------------------------------------------------------------------

NATIVE_IMAGE_UTILS_API
int
hello(const char *msg)
{
  std::string s{msg};
  int result=int(s.size());
  std::cout << "native hello() received '" << msg
            << "' and is about to return " << result << '\n';
  return result;
}

//----------------------------------------------------------------------------
// Blend images
//----------------------------------------------------------------------------

NATIVE_IMAGE_UTILS_API
void
imgBlend(int w1,               // first input image (and result) width
         int h1,               // first input image (and result) height
         const img::Pixel *d1, // first input image pixels (w1*h1)
         int w2,               // second input image width
         int h2,               // second input image height
         const img::Pixel *d2, // second input image pixels (w2*h2)
         int k,                // cursor value within range [0;100]
         img::Pixel *d)        // resulting image pixels (w1*h1)
{
  // ... À COMPLÉTER ...
  //
  // renseigner les `w1*h1' pixels de `d'
  //

#if 1 // uniform colour


#elif 0 // uniform colour dimmed according to k


#elif 0 // copy of d1 dimmed according to k


#elif 0 // full problem (hardcoded loops)


#else // full problem (generic function)


#endif
}

//----------------------------------------------------------------------------
// Reveal an image hidden into another one
//----------------------------------------------------------------------------

NATIVE_IMAGE_UTILS_API
void
imgReveal(int w1,               // input image (and result) width
          int h1,               // input image (and result) height
          const img::Pixel *d1, // input image pixels (w1*h1)
          int k,                // cursor value within range [0;8]
          img::Pixel *d)        // resulting image pixels (w1*h1)
{
  // ... À COMPLÉTER ...
  //
  // renseigner les `w1*h1' pixels de `d'
  //

  // similar to copy of d1 dimmed according to k

}

//----------------------------------------------------------------------------
// Hide an image into another one
//----------------------------------------------------------------------------

NATIVE_IMAGE_UTILS_API
void
imgHide(int w1,               // first input image (and result) width
        int h1,               // first input image (and result) height
        const img::Pixel *d1, // first input image pixels (w1*h1)
        int w2,               // second input image width
        int h2,               // second input image height
        const img::Pixel *d2, // second input image pixels (w2*h2)
        int k,                // cursor value within range [0;8]
        img::Pixel *d)        // resulting image pixels (w1*h1)
{
  // ... À COMPLÉTER ...
  //
  // renseigner les `w1*h1' pixels de `d'
  //

#if 1 // similar to blending (hardcoded loops)


#else // similar to blending (generic function)


#endif
}

//----------------------------------------------------------------------------

ainsi que ces images :

Image input1.ppm
Image input2.ppm
Image brest.ppm
Image enib.ppm

Vous pourrez rendre exécutable le programme Python imageUtils.py✍ grâce à la commande $ chmod +x imageUtils.py ↵

Vous utiliserez le programme Python fourni de la façon suivante : $ ./imageUtils.py blend input1.ppm input2.ppm ↵ Il charge alors les deux images indiquées et en mélange les couleurs pour obtenir une image qu'il affiche à l'écran.
Une tirette permet d'indiquer, par un pourcentage, à quel point la seconde image doit être représentée dans le mélange ; il s'agit de l'effet de fondu-enchaîné (blending).
Ce calcul est effectué par la fonction imgBlend() écrite en Python.
Essayez le programme et constatez, par l'observation des messages apparaissant dans la console suite à la manipulation de la tirette, le temps moyen nécessaire à l'exécution de cette fonction.

{} Interaction entre Python et C++

Le fichier GNUmakefile fourni est celui que nous utilisons habituellement si ce n'est que la ligne suivante a été précisée :

LIB_TARGET=NativeImageUtils

En effet, nous ne cherchons plus à fabriquer un programme exécutable autonome mais une bibliothèque dynamique nommée NativeImageUtils✍ qui sera chargée depuis notre programme Python✍.

Tant que la bibliothèque dynamique en question n'existe pas, le programme imageUtils.py se contente de réaliser tous ses traitements par des algorithmes exprimés en Python.
En revanche, lorsque cette bibliothèque existe, notre programme Python fait usage des fonctions qu'il y trouve (grâce au module ctypes) pour les substituer aux siennes.

À titre d'illustration du procédé, regardez le début de la fonction tryToLoadNativeFunctions() dans le fichier imageUtils.py :

la bibliothèque dynamique NativeImageUtils est recherchée selon le nom spécifique attendu sur la plate-forme d'exécution,
la fonction nommée hello() y est recherchée,
son prototype est spécifié : elle attend une chaîne de caractères (au sens du langage C) et renvoie un entier,
elle est appelée avec une chaîne de caractères en paramètre et son résultat est affiché.

Après avoir fabriqué la bibliothèque dynamique à l'aide de la commande make, une nouvelle exécution du programme imageUtils.py doit indiquer que les fonctions attendues y ont bien été trouvées et l'usage de la fonction hello() doit être visible✍.

Observez maintenant le début du fichier nativeImageUtils.cpp afin de faire le lien avec ce qui vient d'être constaté du côté de Python.
Nous constatons que la fonction hello() a un prototype et une définition très conventionnels en C/C++ ; elle est toutefois précédée d'une macro NATIVE_IMAGE_UTILS_API qui contient la formulation extern "C"✍.
La recherche d'une fonction dans une bibliothèque dynamique a lieu par son nom, ce qui ne pose pas de problème en langage C puisqu'il ne peut y avoir qu'une seule fonction pour un nom donné.
En revanche, le langage C++ offre la surcharge des fonctions : le seul nom d'une fonction n'est alors plus suffisant pour la désigner de manière unique.
La formulation extern "C" indique au compilateur C++ que nous voulons que la fonction concernée puisse être retrouvée de manière unique par son nom comme c'est le cas en langage C✍ bien que celle-ci soit réalisée en C++.
Remarquez également que le paramètre de la fonction hello() est une chaîne au sens du langage C et non std::string.
Ceci est dû au fait que les langages ou applications qui étendent leurs fonctionnalités par des bibliothèques dynamiques ignorent tout des détails des types élaborés de C++✍ ; les conventions concernant la transmission des types de base du langage C sont au contraire bien plus strictement arrêtées.
Rien ne nous empêche cependant d'exploiter ces données simples à travers des types plus élaborés : ici nous fabriquons une donnée de type std::string à partir du paramètre reçu.

À travers l'exemple simpliste de la fonction hello(), nous venons de découvrir le principe qui permet à un langage ou une application d'étendre ses fonctionnalités par du code natif✍.
Ceci passe par la recherche par leur nom de fonctions, réalisées dans une bibliothèque dynamique, qui consomment et produisent des données compatibles avec les types de base du langage C.

{} Fondu enchaîné de deux images

Le premier traitement que nous envisageons de réécrire en C++ concerne le mélange des couleurs de deux images par fondu enchaîné tel que constaté dans cette section.
La fonction imgBlend() de imageUtils.py sera remplacée par sa version réalisée en C++ quand la bibliothèque dynamique NativeImageUtils sera disponible.

Dans le fichier nativeImageUtils.cpp, le prototype de la fonction imgBlend() est déjà renseigné pour recueillir les données nécessaires à l'exécution du traitement souhaité :

les paramètres w1, h1 et d1 décrivent les dimensions et les pixels de la première image indiquée sur la ligne de commande ; cette image ne sera que consultée (pas modifiée),
les paramètres w2, h2 et d2 décrivent les dimensions et les pixels de la seconde image indiquée sur la ligne de commande ; cette image ne sera que consultée (pas modifiée),
le paramètre k indique la position de la tirette de l'interface graphique (un entier interprété comme un pourcentage),
le paramètre d désigne l'emplacement pour accueillir les pixels de l'image résultante (qui sera affichée dans l'interface graphique) ; cette image a les même dimensions que la première et est déjà allouée depuis Python (il n'y a plus qu'à y écrire la valeur des pixels).

Remarquez que le type img::Pixel utilisé pour les paramètres d1, d2 et d est probablement inconnu de Python.
Il s'agit néanmoins d'une simple structure, définie dans le fichier d'en-tête pixel.hpp, qui n'est constituée que de trois composantes de couleurs de type std::uint8_t.
Cette disposition est alors parfaitement conforme à la description précédente✍ et le type img::Pixel nous facilite simplement la manipulation des triplets d'octets sous-jacents.

Il ne reste ici qu'à déterminer le contenu de l'image résultante désignée par d.
Toutefois, nous aborderons ce problème par étapes successives afin de ne pas adresser toutes les difficultés à la fois.
À chacune d'elles, après une nouvelle fabrication de la bibliothèque dynamique, vous testerez le fonctionnement de votre fonction imgBlend() en exécutant $ ./imageUtils.py blend input1.ppm input2.ppm ↵

{} Attribution d'une couleur uniforme

{} Atténuation de la couleur uniforme

{} Atténuation de la première image

{} Réalisation du problème complet

Aucune des étapes précédentes ne nécessitait la prise en compte explicite des coordonnées des pixels considérés : chaque pixel subissait un traitement similaire sur l'ensemble de l'image.
Pour effectuer le mélange de deux images n'ayant pas les mêmes dimensions, il est nécessaire de s'assurer du fait que les motifs de celles-ci restent en leurs places respectives dans l'image résultante (à gauche, à droite, en haut, en bas, au centre...).

Puisque l'image résultante a les dimensions de la première fournie, il nous faudra donc recourir à une transformation des coordonnées pour exploiter la seconde image qui peut avoir des dimensions très différentes.
En revanche, chaque pixel de la première image donnera exactement un pixel de l'image résultante (comme à l'étape précédente).
Ceci peut se traduire par l'algorithme suivant :

Pour chaque pixel x1,y1 de l'image d1.
- Choisir un pixel x2,y2 de l'image d2 placé aux mêmes coordonnées relatives (proportionnalité des largeurs et des hauteurs)✍
  Si x1 est proche de 0, alors x2 doit l'être aussi.
  Si x1 est proche de w1, alors x2 doit être proche de w2.
  Si y1 est proche de 0, alors y2 doit l'être aussi.
  Si y1 est proche de h1, alors y2 doit être proche de h2.
  .
- Déterminer les indices i1 et i2 permettant de désigner ces pixels dans leurs tableaux respectifs (voir les calculs dans cette section).
- Calculer le mélange de couleur entre ces deux pixels en fonction de k et de son complémentaire✍
  Par exemple, si k vaut 20, alors chaque pixel résultant sera constitué de 20 % du pixel pris dans d2 et 80 % du pixel pris dans d1.
  .
- Affecter le pixel ainsi obtenu à l'indice i1 de l'image d résultante.

Remarquez que le parcours de l'image d1 doit reposer sur deux boucles imbriquées :

la boucle externe faisant varier les lignes (y1),
la boucle interne faisant varier les colonnes (x1) sur chacune de ces lignes.

Il aurait été correct, du point de vue algorithmique, de permuter ces deux boucles (les calculs réalisés en leur cœur seraient les mêmes).
Toutefois, la disposition des données de l'image décrites dans cette section indique que les pixels d'une même ligne sont contigus en mémoire, alors les pixels d'une même colonne sont espacés de la largeur d'une ligne.
Les processeurs sont beaucoup plus efficaces lorsqu'ils progressent sur des données contiguës que sur des données espacées✍ ; c'est la raison pour laquelle nous devons préférer la disposition des boucles imbriquées proposée ici.
Un tel parcours si spécifique, avec une progression non triviale de l'indice i2 lors de l'accès aux pixels de d2, ne correspond à aucun algorithme générique standard.
Dans un premier temps, nous le réaliserons avec des boucles de parcours explicites (comme nous le ferions en langage C), mais nous reviendrons sur ce choix ultérieurement.

Le mélange des couleurs des pixels à combiner implique non seulement la multiplication par un réel mais également l'addition des deux pixels ainsi multipliés.
Complétez alors le fichier d'en-tête pixel.hpp pour définir inline, au niveau du commentaire approprié, un nouvel opérateur qui additionne deux pixels.

Vérifiez enfin que cette version complète de votre fonction imgBlend() se comporte bien comme ce que vous avez constaté lors de l'essai du programme utilisant exclusivement Python dans cette section (à la vitesse d'exécution près néanmoins).

Maintenant que la fonction imgBlend() est réalisée en C++, produisez un code exécutable optimisé avec la commande $ make rebuild opt=1 ↵ et relevez alors la performance moyenne obtenue lors de son utilisation $ ./imageUtils.py blend input1.ppm input2.ppm ↵

Faites maintenant disparaître la bibliothèque dynamique avec la commande $ make clean ↵ et reprenez la mesure de performances lorsque seul Python est utilisé.
Au delà de la fluidité dans la manipulation de la tirette, vous devez constater un gain très significatif de performances lorsque notre bibliothèque dynamique est utilisée✍.

Dans ces conditions, nous bénéficions à la fois du confort d'un langage de haut niveau en ce qui concerne la majeure partie de l'application (interface graphique, entrées/sorties) et également de la puissance de calcul des langages C/C++ pour les quelques traitements qui le nécessitent.

{} Représentation binaire des données

Nous nous proposons maintenant d'étendre notre thème applicatif à d'autres traitements concernant la combinaison d'images.
Il s'agit de dissimuler une image dans une autre et de la retrouver ensuite✍.
Bien que le mélange de couleurs réalisé par imgBlend() puisse être considéré comme l'introduction de la seconde image dans la première, il est impossible de séparer les deux images d'origine à partir du résultat obtenu.
Pour atteindre ce but, nous fournirons deux fonctions imgHide() et imgReveal() qui s'utiliseront de manière similaire à imgBlend() (les prototypes sont très semblables).

Nous cherchons à dissimuler la seconde image dans la première, donc les couleurs de la première doivent de toutes façons être prépondérantes dans l'image résultante.
Pour notre démarche, il n'est pas nécessaire de considérer les couleurs comme telles ; nous pouvons simplement les considérer comme deux ensembles de petits entiers variant de 0 à 255.
Ainsi, nous cherchons à produire pour deux d'octets b1 (issu de la première image) et b2 (issu de la seconde image) un octet b qui ne soit pas très éloigné de b1 tout en contenant une information permettant de retrouver une valeur proche de b2.
En raisonnant sur les représentations binaires de ces octets, dire que la valeur de l'octet b est proche de celle l'octet b1 revient à considérer que leurs bits respectifs ne diffèrent qu'au niveau des poids les plus faibles.
Ainsi, pour revenir aux couleurs, si nous annulons les bits de poids faible de chaque octet b1 issu de la première image, nous obtenons une image résultante qui ressemble beaucoup à l'image d'origine ; elle est juste légèrement moins nuancée.
De la même façon, si tous ces bits de poids faible étaient modifiés d'une quelconque manière, l'effet visuel ne concernerait une nouvelle fois que des nuances de couleurs difficilement perceptibles.

Ces bits de poids faible pourront donc nous servir à contenir des informations décrivant la seconde image (celle que nous souhaitons dissimuler).
En suivant le même raisonnement que précédemment, les bits de poids faible de chaque octet b2 issu de la seconde image peuvent être négligés (au prix d'un perte de nuances de couleurs) pour ne conserver que les bits de poids fort.
Ces derniers peuvent alors être inscrits à la place des bits de poids faible de chaque octet obtenu depuis de la première image.
Il faut bien entendu que les bits issus des octets b1 et b2 puissent tenir dans l'octet b résultant : si nous décidons de conserver les k bits de poids fort de l'octet b2, il faut par conséquent ne conserver que les 8-k bits de poids fort de l'octet b1.

Tous les traitements décrits ici peuvent être réalisés de manière très concise et efficace en langage C/C++ à l'aide des opérations bit-à-bit et de décalage (voir ce chapitre du cours S3-PRC).

Assurez vous d'avoir bien compris ceci avant de poursuivre !

{} Révélation d'une image dissimulée dans une autre

Pour commencer par la partie la plus facile, nous allons tout d'abord faire en sorte que les commandes suivantes : $ ./imageUtils.py reveal brest.ppm ↵ $ ./imageUtils.py reveal enib.ppm ↵ révèlent les images qui ont été préalablement dissimulées dans les images brest.ppm et enib.ppm fournies✍.

Pour ceci, la fonction imgReveal() du fichier nativeImageUtils.cpp sera invoquée d'une manière très semblable à ce qui a été fait dans le cas de imgBlend() ; toutefois, cette fonction ne consulte qu'une seule image.
Il s'agit d'extraire, pour une position k (variant de 0 à 8) contrôlée par la tirette de l'interface graphique, les k bits de poids faible de chaque octet de l'image d1 afin de produire l'image d résultante.
L'algorithme général est très similaire à celui précédemment réalisé pour la copie atténuée de l'image d1 : une simple boucle générique applique une transformation à chacun des pixels.
Il ne s'agit cependant pas cette fois-ci d'une multiplication par un réel mais d'une opération de décalage.
Il vous faudra donc compléter le fichier pixel.hpp avec la définition inline de l'opérateur approprié.

Exemple informel

Vérifiez enfin que votre fonction imgReveal() se comporte bien comme son équivalent en Python.
Ce procédé simpliste dégrade très fortement les nuances de couleur puisqu'une quantité non négligeable des bits de l'image cachée est sacrifiée.
Vous devriez constater que l'image enib.ppm ne consacre que deux bits à son image cachée ; les couleurs très tranchées de cette dernière s'accommodent en effet de très peu de nuances.
L'image brest.ppm consacre trois bits à son image cachée ; les dégradés de couleur de cette dernière sont déjà fortement altérés et il serait très dommageable d'accentuer ce phénomène.

{} Dissimulation d'une image dans une autre

Nous envisageons maintenant de dissimuler l'image input2.ppm dans l'image input1.ppm avec la commande suivante✍ : $ ./imageUtils.py hide input1.ppm input2.ppm ↵

Pour ceci, la fonction imgHide() du fichier nativeImageUtils.cpp sera invoquée d'une manière très semblable à ce qui a été fait dans le cas de imgBlend().
Il s'agit de placer, pour une position k (variant de 0 à 8) contrôlée par la tirette de l'interface graphique, dans chaque octet b de l'image d résultante :

les 8-k bits de poids fort des octets b1 provenant de l'image d1,
- ses k bits de poids faible doivent alors être forcés à zéro,
les k bits de poids fort des octets b2 provenant de l'image d1,
- ces k bits doivent alors être déplacés vers les poids faibles,
- ce qui introduira 8-k bits de poids fort valant zéro.

Les deux images d1 et d2 n'ayant pas nécessairement les mêmes dimensions il faudra effectuer des transformations de coordonnées identiques à celles réalisées dans imgBlend() ; seule la combinaison des composantes de couleurs sera effectuée d'une manière différente ici.
Il ne s'agit pas cette fois-ci de multiplication par un réel et d'addition mais d'opérations bit-à-bit et de décalage.
Il vous faudra donc compléter le fichier pixel.hpp avec les définitions inline des opérateurs appropriés.

Exemple informel

Pour obtenir un résultat intéressant, il faut manipuler la tirette pour essayer de maximiser le nombre de bits consacrés à l'image d2 (cachée) tout en ayant une image d résultante qui soit visuellement très semblable à l'image d1.
Vérifiez enfin que votre fonction imgHide() se comporte bien comme son équivalent en Python.
En quittant l'outil, l'image résultante est sauvegardée ; vous pouvez alors tester si la séparation des deux images s'effectue correctement à l'aide de cette commande : $ ./imageUtils.py reveal output_imgHide.ppm ↵ En choisissant avec la tirette de l'interface graphique le bon nombre de bits consacrés à l'image cachée, vous devriez voir apparaître cette dernière (avec des nuances de couleur fortement altérées cependant).
Vous disposez dorénavant d'un outil vous permettant de dissimuler et révéler des images de votre choix les unes dans les autres.

{} Factorisation du code source

Nous avons constaté, lors des réalisations des fonctions imgBlend() et imgHide(), que l'algorithme de parcours visant à sélectionner la paire de pixels provenant respectivement des images d1 et d2 était strictement identique dans les deux cas.
Seule changeait la façon de combiner ces deux pixels pour obtenir celui qui devait être placé dans l'image résultante.

La réplication à l'identique de telles portions de code source dans de multiples traitements✍ est fortement déconseillé : en effet, si nous décidions d'y apporter une modification, il faudrait alors la répéter en de multiples endroits du code source.
De plus, de telles boucles avec compteur, impliquant des calculs d'indices, sont potentiellement des sources de maladresses : il serait donc très raisonnable de traiter ce problème une fois pour toutes dans une unique fonction, afin ne plus avoir à le considérer ailleurs puisqu'il suffirait alors de s'appuyer sur cette unique fonction supposée correcte.

Complétez alors le fichier pixel.hpp avec la définition inline d'une fonction merge(), au niveau du commentaire approprié.
Ses paramètres doivent lui donner accès aux trois images considérées✍ et elle doit également accepter une lambda-closure reposant sur un type template.
Son algorithme est principalement constitué des deux boucles imbriquées et des calculs d'indices que vous avez déjà réalisés.
Au cœur de ces boucles, il suffit d'invoquer la lambda-closure reçue en paramètre afin de combiner la paire de pixels sélectionnée et ainsi obtenir le pixel à placer dans l'image résultante.

Après avoir conservé en commentaire les formulations précédentes des fonctions imgBlend() et imgHide(), reformulez-les en vous appuyant sur votre fonction merge().
Il suffira de lui transmettre une lambda-closure qui capture toutes les données qui sont nécessaires à l'expression de la combinaison de deux pixels considérés.
Vérifiez que, dans ces nouvelles conditions, vos fonctions se comportent exactement comme avec leur formulation précédente.