Discussion :

[cincap]

Bonjour à toutes et à tous,

Avec ce code batch, je télécharge les photos et j'ajoute l'extension, cela fonctionne correctement.

Mais j'aurai préféré en plus ne télécharger que les photos qui ont la largeur plus grande que la hauteur soit 1920 x 1080 afin de limiter la quantité de photos à télécharger.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
@echo off
if not exist "%USERPROFILE%\pictures\Windows SpotLight" ( 
	mkdir "%USERPROFILE%\pictures\Windows SpotLight" 
)
echo Copie des fichiers Windows a la une en cours..
copy %localappdata%\Packages\Microsoft.Windows.ContentDeliveryManager_cw5n1h2txyewy\LocalState\Assets\* "%USERPROFILE%\pictures\Windows SpotLight\*.jpg" > null
echo la copie est terminée

pause

Merci d'avance,

@+,

cincap

[fred1599]

Hello,

Comment penses-tu pouvoir récupérer les dimensions (largeur et hauteur) d'un fichier image en utilisant uniquement des commandes batch natives ?
Le batch est puissant pour la manipulation de fichiers, mais a-t-il accès aux métadonnées des images ? Je ne pense pas !

As-tu envisagé d'utiliser PowerShell pour cette tâche ?

----

Un peu hors sujet, le script actuel utilise copy ...\Assets\* ...\*.jpg. Cette commande copie tous les fichiers du dossier Assets et leur ajoute l'extension .jpg, qu'il s'agisse d'images ou non (le dossier Assets peut contenir des icônes, des logos ou d'autres fichiers de taille variable qui ne sont pas des fonds d'écran). N'y a-t-il pas un risque de créer des fichiers .jpg corrompus et inutiles ?

Pour pouvoir vérifier chaque fichier (que ce soit par sa taille ou, idéalement, par ses dimensions), une copie en bloc avec * n'est pas la plus adaptée.
Ne serait-il pas plus judicieux de parcourir chaque fichier du dossier Assets avec une boucle FOR, ce qui permettrait d'exécuter une série de tests sur chaque fichier avant de décider de le copier ?

[cincap]

Bonjour à toutes et à tous,

@ fred1599, merci pour ta réponse, en Delphi, mon application est fonctionnelle, elle fait le tri, elle affiche dans une liste les photos disponibles en 1920 x 1080, et copie la photo dans le clipboard.

le dossier Assets peut contenir des icônes, des logos ou d'autres fichiers de taille variable qui ne sont pas des fonds d'écran

Sur mon Pc Windows 11 64 bits dernière version, il n'y a que les photos sans extension en 1920 x 1080 et 1080 x 1920.

Avec le code communiqué j'ai rajouté un décompte de 10 s et l'ouverture du dossier ou sont copiées les photos avec l'extension .jpg.

En 2016 j'avais un script qui faisait le tout mais avec la version de PowerShell que j'ai cela ne fonctionne pas.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
<#
.DESCRIPTION
Copie les images de l'écran de verrouillage Windows Spotlight de Windows 10 dans un dossier «*Windows Spotlight*» de Mes images.

Ce script trie intelligemment le répertoire temporaire et copie uniquement les images de 1920 x 1080. Les noms de fichiers des images étant variables, le script compare également les hachages SHA1 des images existantes afin d'éviter les doublons.

.NOTES
  Version:        1.0.4
  Author:         jcefoli
  Creation Date:  3/14/2016
  
  Only tested in Powershell 4 on Windows 10

.EXAMPLE
  Run from the Command Prompt (As Admin) like so:

  Straight from GitHub:
    @powershell -NoProfile -ExecutionPolicy Bypass -Command "iex ((new-object net.webclient).DownloadString('https://gist.github.com/patrickgreenwell/a7a985b94d6558f0b75903a5c5922209/raw/SaveSpotlightImages.ps1'))"

  Local Path (assumes you download the script to the C:\ root)"
    @powershell -NoProfile -ExecutionPolicy Bypass C:\SaveSpotlightImages.ps1

Vous pouvez configurer cela pour qu'il s'exécute sans fenêtre en utilisant un script VB comme celui-ci (notez que vous devez double-échapper les guillemets doubles dans la commande PowerShell*:
    Dim shell,command
    command = "powershell -NoProfile -ExecutionPolicy Bypass -Command ""iex ((new-object net.webclient).DownloadString('https://gist.github.com/patrickgreenwell/a7a985b94d6558f0b75903a5c5922209/raw/SaveSpotlightImages.ps1'))"""
    Set shell = CreateObject("WScript.Shell")
    shell.Run command,0
#>
$StartTime = Get-Date

###------------------------------------------------------------------------------------------###
###                SET IMAGE COPY LOCATION HERE                                              ###
###   Defaults to "Windows Spotlight" folder in your Pictures                                ###
$horizontalImageRestorePath = "$env:USERPROFILE\Pictures\Windows Spotlight"
$verticalImageRestorePath = "$env:USERPROFILE\Pictures\Windows Spotlight (Vertical)"
###------------------------------------------------------------------------------------------###

#Effacer le terminal et ajouter un message de chargement
Clear-Host
Write-Host ""
Write-Host " Working some magic. Please wait! "
Write-Host ""

#Charger le système.dessin Assemblage
[void][reflection.assembly]::loadwithpartialname("system.drawing")

#Fonction pour obtenir les métadonnées de l'image
function Get-Image{ 
  process {
    $file = $_
    [Drawing.Image]::FromFile($_.FullName)  |
    ForEach-Object{           
      $_ | Add-Member -PassThru NoteProperty FullName ('{0}' -f $file.FullName)
      $_.Dispose()
    }
  }
}

#Créer un répertoire temporaire
$checkDir = Test-Path $env:TEMP\bgtempimages
If ($checkDir -eq $False){
  New-Item $env:TEMP\bgtempimages -Type directory | Out-Null
}
Else {
  $fso = New-Object -ComObject scripting.filesystemobject
  $fso.DeleteFolder("$env:TEMP\bgtempimages*")
}

#Copier les ressources de l'emplacement Windows vers le répertoire temporaire
Copy-Item $env:LOCALAPPDATA\Packages\Microsoft.Windows.ContentDeliveryManager_cw5n1h2txyewy\LocalState\Assets\* -Destination $env:TEMP\bgtempimages\

#Ajouter l'extension .jpg aux fichiers
Get-ChildItem -Path "$env:TEMP\bgtempimages" | Rename-Item -newname  { $_.Name + ".jpg" }

#Détecter et supprimer les fichiers XML malveillants
$tempFileList = Get-ChildItem -Path "$env:TEMP\bgtempimages" | Select-Object FullName
ForEach ($file in $tempFileList) { 
  $isXML = [bool]((Get-Content $file.FullName) -as [xml])
  if ($isXML -eq $True) {
    Remove-Item $file.FullName
  }
}

#Créer un répertoire d'images d'arrière-plan permanent s'il n'existe pas
$checkDir = Test-Path $horizontalImageRestorePath
If ($checkDir -eq $False){
  New-Item $horizontalImageRestorePath -Type directory | Out-Null
}
$checkDir = Test-Path $verticalImageRestorePath
If ($checkDir -eq $False){
  New-Item $verticalImageRestorePath -Type directory | Out-Null
}
#Le dossier existe, alors récupérez les hachages SHA1 de toutes les images existantes afin de ne pas copier des arrière-plans en double avec des noms de fichiers différents
  $existingImageObjects = Get-ChildItem -Path $horizontalImageRestorePath | Select-Object -expa Fullname
  $existingImageObjects += Get-ChildItem -Path $verticalImageRestorePath | Select-Object -expa FullName
  
#Ajoutez tous les hachages du répertoire d'images permanent à $existingHashesArray
  $existingHashesArray = @()
  ForEach ($filepath in $existingImageObjects ) {
    $existingHashesArray += Get-FileHash -Path $filepath -Algorithm SHA1
  }

#Détecter les images de 1920x1080 (les images d'arrière-plan que nous voulons déplacer)
$horizontalImagesToCopy = Get-ChildItem -Path "$env:TEMP\bgtempimages" -Filter *.* -Recurse  | Get-Image | Where-Object { $_.Width -eq 1920 -or $_.Height -eq 1080 } | Select-Object -expa Fullname
$verticalImagesToCopy = Get-ChildItem -Path "$env:TEMP\bgtempimages" -Filter *.* -Recurse  | Get-Image | Where-Object { $_.Width -eq 1080 -or $_.Height -eq 1920 } | Select-Object -expa Fullname

#Obtenez les hachages de ces images 1920x1080 et stockez-les dans $newHorizontalImageHashArray
$newHorizontalImageHashArray = @()
ForEach ($filepath in $horizontalImagesToCopy ) { 
    $newHorizontalImageHashArray += Get-FileHash -Path $filepath -Algorithm SHA1
}

$newVerticalImageHashArray = @()
ForEach ($filepath in $verticalImagesToCopy ) { 
  $newVerticalImageHashArray += Get-FileHash -Path $filepath -Algorithm SHA1
}

#Boucle sur les images horizontales temporaires à copier
$i = 0
$newHorizontalImageHashArray | ForEach-Object {
  if ($existingHashesArray.Hash -Contains $_.Hash){
    #Found duplicate hash in existing directory, do not copy new image over
  }
  Else {
   
#Nouvel arrière-plan trouvé*! Copiez-le
    Copy-Item $_.Path -Destination $horizontalImageRestorePath
    $i++ 
    }
}

#Boucle à travers les images verticales temporaires à copier
$j = 0
$newVerticalImageHashArray | ForEach-Object {
  if ($existingHashesArray.Hash -Contains $_.Hash){
    #Found duplicate hash in existing directory, do not copy new image over
  }
  Else {
   
#Nouvel arrière-plan trouvé*! Copiez-le
    Copy-Item $_.Path -Destination $verticalImageRestorePath
    $j++
  }
}

#Sortie d'état
$FinishTime = Get-Date
$TotalTime = ($FinishTime - $StartTime).TotalMilliseconds

if ($i -eq 0) {
  Write-host "[Done] - No images copied. Took $TotalTime ms." -foregroundcolor "Yellow"
}
ElseIF ($i -eq 1){
  Write-host "[Done] - Copied $i image. Took $TotalTime ms." -foregroundcolor "Green"
}
Else{
  Write-host "[Done] - Copied $i images. Took $TotalTime ms." -foregroundcolor "Green"
}

#Supprimer le dossier temporaire
$fso = New-Object -ComObject scripting.filesystemobject
$fso.DeleteFolder("$env:TEMP\bgtempimages*")

Encore merci pour tes suggestions,

@+,
cincap

[fred1599]

C'est déjà plus clair,

Ce script PowerShell de 2016 est une excellente base, car sa logique de dédoublonnage avec les hachages SHA1 est très robuste. Cependant, comme tu l'as constaté, PowerShell a beaucoup évolué depuis, et certaines pratiques de l'époque ne sont plus optimales aujourd'hui.

La logique de détection des doublons est parfaite et doit être conservée. En corrigeant le bug du filtre -or et en modernisant les quelques commandes obsolètes, il sera parfaitement fiable et performant sur Windows 11.

Voici une proposition,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
# --- Configuration des chemins ---
$sourcePath = "$env:LOCALAPDATA\Packages\Microsoft.Windows.ContentDeliveryManager_cw5n1h2txyewy\LocalState\Assets"
$destinationPathPaysage = "$env:USERPROFILE\Pictures\Windows Spotlight (Paysage)"
$destinationPathPortrait = "$env:USERPROFILE\Pictures\Windows Spotlight (Portrait)"

# --- Début du script ---
$stopwatch = [System.Diagnostics.Stopwatch]::StartNew()
Write-Host "Lancement du traitement des images Windows Spotlight..." -ForegroundColor Cyan

# 1. Chargement de l'assembly nécessaire pour la manipulation d'images (méthode moderne)
try {
    Add-Type -AssemblyName System.Drawing
}
catch {
    Write-Error "Impossible de charger le module System.Drawing. Le script ne peut pas continuer."
    exit 1
}

# 2. Création des dossiers de destination s'ils n'existent pas (méthode native)
@( $destinationPathPaysage, $destinationPathPortrait ) | ForEach-Object {
    if (-not (Test-Path -Path $_)) {
        Write-Host "Création du dossier : $_"
        New-Item -Path $_ -ItemType Directory -Force | Out-Null
    }
}

# 3. Récupération des hachages des images déjà présentes pour éviter les doublons
Write-Host "Analyse des images existantes pour éviter les doublons..."
$existingFiles = Get-ChildItem -Path $destinationPathPaysage, $destinationPathPortrait -Filter "*.jpg" -File

# Utilisation d'un HashSet pour une recherche ultra-rapide des doublons
$existingHashes = [System.Collections.Generic.HashSet[string]]::new(
    ($existingFiles | Get-FileHash -Algorithm SHA1).Hash
)
Write-Host "$($existingHashes.Count) images déjà présentes."

# 4. Traitement des nouveaux fichiers en une seule passe
Write-Host "Recherche de nouvelles images dans le dossier Assets..."
$newImagesCopied = 0
$assets = Get-ChildItem -Path $sourcePath -File | Where-Object { $_.Length -gt 200KB } # Pré-filtrage par taille

foreach ($asset in $assets) {
    $image = $null
    try {
        # Tente de charger le fichier comme une image
        $image = [System.Drawing.Image]::FromFile($asset.FullName)

        # Vérification des dimensions
        $isPaysage = ($image.Width -eq 1920 -and $image.Height -eq 1080)
        $isPortrait = ($image.Width -eq 1080 -and $image.Height -eq 1920)

        if ($isPaysage -or $isPortrait) {
            # Si les dimensions correspondent, on calcule le hachage
            $currentHash = (Get-FileHash -Path $asset.FullName -Algorithm SHA1).Hash

            # On vérifie si l'image n'existe pas déjà
            if (-not $existingHashes.Contains($currentHash)) {
                
                # Sélection du bon dossier de destination
                if ($isPaysage) {
                    $destinationPath = $destinationPathPaysage
                } else {
                    $destinationPath = $destinationPathPortrait
                }

                $newFileName = "$currentHash.jpg" # Nommer le fichier par son hachage est une pratique robuste
                
                # Copie du fichier
                Copy-Item -Path $asset.FullName -Destination (Join-Path $destinationPath $newFileName)

                # Mise à jour de nos compteurs et listes
                $newImagesCopied++
                $existingHashes.Add($currentHash) | Out-Null # On ajoute le hachage à la liste pour éviter les doublons internes
                Write-Host " -> Nouvelle image copiée : $newFileName" -ForegroundColor Green
            }
        }
    }
    catch {
        # Ce n'était probably pas un fichier image, on ignore l'erreur et on continue
    }
    finally {
        # TRÈS IMPORTANT: Libérer le fichier pour éviter qu'il soit verrouillé
        if ($null -ne $image) {
            $image.Dispose()
        }
    }
}

# --- Fin du script ---
$stopwatch.Stop()
$duration = $stopwatch.Elapsed.TotalSeconds.ToString("F2")

Write-Host "--------------------------------------------------" -ForegroundColor Cyan
if ($newImagesCopied -eq 0) {
    Write-Host "Aucune nouvelle image trouvée. Opération terminée en $duration secondes." -ForegroundColor Yellow
}
else {
    Write-Host "Opération terminée ! $newImagesCopied nouvelle(s) image(s) copiée(s) en $duration secondes." -ForegroundColor Green
}

# Ouvre le dossier s'il y a eu de nouvelles images
if ($newImagesCopied -gt 0) {
    Invoke-Item $destinationPathPaysage
}

Bien vérifier les chemins !

[cincap]

@ fred1599,

merci pour ta patience, j'ai testé après avoir vérifié les chemins et sur mon Pc je n'ai que avec le click droit "Executer avec PowerShell" même pas en tant qu'Administrateur.

Cela ne fonctionne pas la fenêtre s'ouvre puis se ferme automatiquement donc je ne sais pas voir si il y a des erreurs.

Je suppose que l'extension .ps1 est toujours valable à toutes fin ce serait bien d'avoir un lien avec la nouvelle version de PowerShell au format msi.

@+,

cincap

[cincap]

@fred1599, j'ai du créer un lanceur Ps1 en .bat car malgré la dernière version de PowerShell, je n'ai pas sut démarrer le script ensuite, j'ai vu une erreur au chemin des photos soit

$sourcePath = "APPDATALOCAL....." au lieu de "LOCALAPDATA........"

Ensuite, je pense que le script vérifie si il existe des nouvelles photos avant d'en avoir dans les dossiers donc erreur.

@+,

cincap

[fred1599]

je pense que le script vérifie si il existe des nouvelles photos avant d'en avoir dans les dossiers donc erreur

Rassure-toi, ce n'est pas une erreur. Le script a été conçu pour ce cas de figure !La commande Get-ChildItem est intelligente : si le dossier est vide, elle ne retourne tout simplement rien. La variable $existingFiles sera vide, et donc la liste des hachages $existingHashes sera également vide. Le script continuera ensuite son exécution normalement et copiera les premières images qu'il trouvera. C'est le comportement attendu pour le tout premier lancement.

Je suppose que l'extension .ps1 est toujours valable à toutes fin ce serait bien d'avoir un lien avec la nouvelle version de PowerShell au format msi.

Tu as raison, l'extension .ps1 est toujours valable.
Il existe deux versions de PowerShell :

• Windows PowerShell 5.1 : Celle intégrée à Windows, que tu utilises probablement.
• PowerShell 7 (ou plus) : La version moderne et open-source. Elle est plus performante et reçoit les mises à jour.

Le script écrit est compatible avec les deux versions. Mais si tu souhaites installer la dernière version, tu peux faire une recherche, tu là trouveras facilement.

Cela ne fonctionne pas la fenêtre s'ouvre puis se ferme automatiquement donc je ne sais pas voir si il y a des erreurs.

C'est le symptôme typique de la stratégie d'exécution (Execution Policy) de PowerShell. Par défaut, pour des raisons de sécurité, Windows empêche l'exécution de scripts .ps1 téléchargés ou créés localement.
Pour corriger cela de manière permanente et sécurisée, il suffit d'exécuter une seule commande une seule fois.
Comment faire :

1. Clique sur le menu Démarrer, tape "PowerShell".
2. Sur "Windows PowerShell", fais un clic droit et sélectionne "Exécuter en tant qu'administrateur".
3. Dans la fenêtre bleue qui s'ouvre, tape la commande suivante:
   

   Code :

   Sélectionner tout - Visualiser dans une fenêtre à part

   Set-ExecutionPolicy RemoteSigned

4. PowerShell va te demander une confirmation.

C'est tout ! Tu peux fermer cette fenêtre administrateur. Maintenant, tu pourras exécuter tes scripts avec un simple clic droit > "Exécuter avec PowerShell", sans qu'ils se ferment instantanément.

[cincap]

Bonjour à toutes et à tous,

@ fred1599, merci pour toutes ces suggestions, j'ai installé la version 7 mais rien n'indique que c'est cette version que j'utilise ?

Pour mettre "Set-ExecutionPolicy RemoteSigned" j'ai du ouvrir PowerShell et choisir "Exécuter en tant qu'Administrateur".

Sinon en rajoutant pause dans le script j'ai put lire le résultat :

Lancement du traitement des images Windows Spotlight...
Analyse des images existantes pour éviter les doublons...
Plusieurs surcharges ambiguës trouvées pour «*new*» et le nombre d'arguments «*1*».
Au caractère C:\Users\cincap\MAX\Data\JMC_Extracteur_Logon\JMC_ViewerLogon_2025\MonScript.ps1:33 : 1
+ $existingHashes = [System.Collections.Generic.HashSet[string]]::new(
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ CategoryInfo : NotSpecified: ( [], MethodException
+ FullyQualifiedErrorId : MethodCountCouldNotFindBest

0 images déjà présentes.
Recherche de nouvelles images dans le dossier Assets...
--------------------------------------------------
Aucune nouvelle image trouvée. Opération terminée en 0,39 secondes.
Cliquez sur Entrée pour continuer...:

Les deux dossiers sont créé mais aucune photo.

As tu tenu compte que dans le dossier "Assets" les photos n'ont pas d'extension : (3c267268f06b2c74c362bac4167e4e4c61cb6c4248ebb68905f2aa79e5701d3b).

Je vérifie aussi le pourquoi.

Bon dimanche,

cincap

[fred1599]

j'ai installé la version 7 mais rien n'indique que c'est cette version que j'utilise ?

Tape cette commande : $PSVersionTable dans ta fenêtre PowerShell.

Arrête d'utiliser le clic droit "Exécuter avec PowerShell", car il est presque toujours lié à l'ancienne version. Fais les choses proprement :

1. Lance PowerShell 7
   
2. Glisse ton fichier .ps1 directement dans cette fenêtre
   
3. Appuie sur la touche Entrée.

C'est la méthode la plus simple et la plus fiable pour être certain d'utiliser la bonne version.

Pour mettre "Set-ExecutionPolicy RemoteSigned" j'ai du ouvrir PowerShell et choisir "Exécuter en tant qu'Administrateur".

Euh oui c'est ce que j'avais précisé dans mon précédent message non ?

----

Concernant ton erreur, je pense que tu exécutes avec l'ancienne version PowerShell

PowerShell 5.1 ne comprend pas bien la syntaxe moderne [System.Collections.Generic.HashSet[string]]::new(...)J'ai modifié la ligne qui pose problème pour la remplacer par une syntaxe plus ancienne que même PowerShell 5.1 peut comprendre. Ça rend le code un peu moins élégant, mais bon

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

# --- Configuration des chemins ---
$sourcePath              = "$env:LOCALAPPDATA\Packages\Microsoft.Windows.ContentDeliveryManager_cw5n1h2txyewy\LocalState\Assets"
$destinationPathPaysage  = "$env:USERPROFILE\Pictures\Windows Spotlight (Paysage)"
$destinationPathPortrait = "$env:USERPROFILE\Pictures\Windows Spotlight (Portrait)"


# --- Début du script ---
$stopwatch = [System.Diagnostics.Stopwatch]::StartNew()
Write-Host "Lancement du traitement des images Windows Spotlight..." -ForegroundColor Cyan


# 1. Chargement de l'assembly (compatible PS5.1 et PS7)
try {
    Add-Type -AssemblyName System.Drawing
}
catch {
    Write-Error "Impossible de charger le module System.Drawing."
    # Ajout d'une pause en cas d'erreur pour voir le message
    Write-Host "Appuie sur Entrée pour fermer..."
    Read-Host
    exit 1
}


# 2. Création des dossiers de destination (compatible PS5.1 et PS7)
@( $destinationPathPaysage, $destinationPathPortrait ) | ForEach-Object {
    if (-not (Test-Path -Path $_)) {
        Write-Host "Création du dossier : $_"
        New-Item -Path $_ -ItemType Directory -Force | Out-Null
    }
}


# 3. Récupération des hachages (syntaxe modifiée pour compatibilité PS5.1)
Write-Host "Analyse des images existantes pour éviter les doublons..."
# L'option -ErrorAction SilentlyContinue évite un message d'erreur si les dossiers sont vides
$existingFiles = Get-ChildItem -Path $destinationPathPaysage, $destinationPathPortrait -Filter "*.jpg" -File -ErrorAction SilentlyContinue


# Création du HashSet via l'ancienne méthode, 100% compatible
$existingHashes = [System.Collections.Generic.HashSet[string]]::new()
# On vérifie que $existingFiles n'est pas vide avant de continuer
if ($null -ne $existingFiles) {
    ($existingFiles | Get-FileHash -Algorithm SHA1).Hash | ForEach-Object {
        # L'ajout de `$null =` est une astuce pour ne pas polluer la console avec la sortie de la fonction .Add()
        $null = $existingHashes.Add($_)
    }
}
Write-Host "$($existingHashes.Count) images déjà présentes."




# 4. Traitement des nouveaux fichiers (compatible PS5.1 et PS7)
Write-Host "Recherche de nouvelles images dans le dossier Assets..."
$newImagesCopied = 0
$assets = Get-ChildItem -Path $sourcePath -File | Where-Object { $_.Length -gt 200KB }


foreach ($asset in $assets) {
    $image = $null
    try {
        # Lecture du fichier image
        $image = [System.Drawing.Image]::FromFile($asset.FullName)


        # Vérification précise des dimensions
        $isPaysage = ($image.Width -eq 1920 -and $image.Height -eq 1080)
        $isPortrait = ($image.Width -eq 1080 -and $image.Height -eq 1920)


        if ($isPaysage -or $isPortrait) {
            # Calcul du hachage uniquement pour les images valides
            $currentHash = (Get-FileHash -Path $asset.FullName -Algorithm SHA1).Hash
            
            # Vérification de l'existence du hachage
            if (-not $existingHashes.Contains($currentHash)) {
                
                # Choix du dossier et copie
                $destinationPath = if ($isPaysage) { $destinationPathPaysage } else { $destinationPathPortrait }
                $newFileName = "$currentHash.jpg"
                Copy-Item -Path $asset.FullName -Destination (Join-Path $destinationPath $newFileName)
                
                # Mise à jour des compteurs
                $newImagesCopied++
                $null = $existingHashes.Add($currentHash)
                Write-Host "  -> Nouvelle image copiée : $newFileName" -ForegroundColor Green
            }
        }
    }
    catch {
        # Le bloc est vide pour ignorer les fichiers qui ne sont pas des images
    }
    finally {
        # Libération du fichier, étape cruciale
        if ($null -ne $image) {
            $image.Dispose()
        }
    }
}


# --- Fin du script ---
$stopwatch.Stop()
$duration = $stopwatch.Elapsed.TotalSeconds.ToString("F2")
Write-Host "--------------------------------------------------" -ForegroundColor Cyan


if ($newImagesCopied -eq 0) {
    Write-Host "Aucune nouvelle image trouvée. Opération terminée en $duration secondes." -ForegroundColor Yellow
}
else {
    Write-Host "Opération terminée ! $newImagesCopied nouvelle(s) image(s) copiée(s) en $duration secondes." -ForegroundColor Green
    # Ouvre le dossier principal des images si des ajouts ont été faits
    Invoke-Item "$env:USERPROFILE\Pictures"
}


# Pause finale pour voir le résultat avant la fermeture
Write-Host "Appuie sur Entrée pour fermer..."
Read-Host

[cincap]

@ fred1599, Avec ta correction tout est en ordre et génial le fait de séparer les photos par leur largeur.

En tous les cas grand merci pour ta solution.

Je vais examiner les deux versions pour mieux comprendre.

@+,

cincap