【PowerShell】Webpに変換した画像ファイルの向きを直す

1
function Set-ImageOrientations([string]$orgSuffix) {
2
  $updatedCount = 0;
3
  $targetExt = ".jpg";
4
  Write-Host ("{0}: aaaaaaaaaaaaaaaaaaaaaaaaaaaaa`n" -f $MyInvocation.MyCommand.Name);
5

6
  Get-ChildItem *$targetExt | ForEach-Object {
7
    $img = $_.FullName;
8
    $isPathCorrect = Test-Path $img;
9
    Write-Output $img;
10
    Write-Output $isPathCorrect;
11
    Write-Host ("{0}: cccccccccccccccccccccccccccc`n" -f $MyInvocation.MyCommand.Name);
12
    if ($isPathCorrect -eq $false) {
13
      continue;
14
    }
15

16
    $suffix = "_orien";
17
    $suffixWithExt = "{0}{1}" -f $suffix, $targetExt;
18
    $imgOriented = $img.Replace($targetExt, $suffixWithExt);
19
    Set-ImageOrientation $img $imgOriented $orgSuffix;
20

21
    $updatedCount++;
22
  };
23
  Write-Output("{0} images confirmed." -f $updatedCount);
24
  Write-Host ("{0}: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`n" -f $MyInvocation.MyCommand.Name);
25
}
26

27
function Set-ImageOrientation([string]$srcRelPath, [string]$dstRelPath, [string]$suffix) {
28
  $inputPath = (Resolve-Path $srcRelPath).Path;
29
  $outputPath = $dstRelPath;
30
  $outputPath = $outputPath.Replace(".\", "");
31

32
  $relDirOwningLog = ".";
33
  $strCmd = "{0}/exiftool.exe" -f $relDirOwningLog;
34
  $argumentArray = @("-T", "-Orientation", $inputPath)
35
  $arguments = $argumentArray -join " ";
36
  $oResult = Invoke-ExternalCommand $strCmd $arguments;
37
  # Write-Output $oResult.stdout;
38
  # Write-Host $oResult.stdout;
39

40
  $orientation = Write-Output $oResult.stdout;
41
  Add-Type -AssemblyName System.Drawing;
42
  $rotateFlipType = [System.Drawing.RotateFlipType]::Rotate90FlipNone;
43

44
  Write-Output $orientation;
45
  Write-Host ("{0}: aaaaaaaaaaaaaaaaaaaaaaaaaaaaa`n" -f $MyInvocation.MyCommand.Name);
46
  $clockwisedStr = "Rotate 90 CW";
47
  if ($orientation -eq $clockwisedStr) {
48
    Write-Host ("{0}: 90 degree clockwised." -f $inputPath);
49
  }
50
  elseif ($orientation -eq "Rotate 180") {
51
    $rotateFlipType = [System.Drawing.RotateFlipType]::Rotate180FlipNone;
52
    Write-Host ("{0}: 180 degree clockwised." -f $inputPath);
53
  }
54
  elseif ($orientation -eq "-") {
55
    Write-Host ("{0}: unclockwised." -f $inputPath);
56
    return $false;
57
  }
58
  elseif ($orientation -eq "Unknown (0)") {
59
    Write-Host ("{0}: this file skipping." -f $inputPath);
60
    return $false;
61
  }
62
  else {
63
    Write-Host ("{0}: Unknown orientation value: '{1}'" -f $inputPath, $orientation);
64
    return $false;
65
  }
66
  Write-Host ("{0}: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`n" -f $MyInvocation.MyCommand.Name);
67
  Write-Output $inputPath;
68
  Write-Output $outputPath;
69
  Write-Output $rotateFlipType;
70
  Write-Host ("{0}: ccccccccccccccccccccccccccccccccccc`n" -f $MyInvocation.MyCommand.Name);
71

72
  $img = [System.Drawing.Image]::FromFile($inputPath);
73
  $img.RotateFlip($rotateFlipType); ###############################
74
  $img.Save($outputPath, [System.Drawing.Imaging.ImageFormat]::Jpeg);
75
  $img.Dispose();
76
  Write-Host ("{0}: dddddddddddddddddddddddddddddddddd`n" -f $MyInvocation.MyCommand.Name);
77

78
  function Get-FileName([string]$absPath) {
79
    $path = (Resolve-Path -Path $absPath -Relative);
80
    $item = (Get-Item -Path (Resolve-Path -Path $path -Relative));
81
    $baseName = $item.BaseName;
82
    $ext = $item.Extension;
83
    $fileName = "{0}{1}" -f $baseName, $ext;
84
    return $fileName;
85
  }
86

87
  # Rename a source file and a destination file.
88
  $orgFileName = (Get-FileName $inputPath);
89
  # $newFileName = (Get-FileName $outputPath);
90
  Write-Output $inputPath;
91
  Write-Output $outputPath;
92
  Write-Output $suffix;
93
  Write-Host ("{0}: ffffffffffffffffffffffffffffffffff`n" -f $MyInvocation.MyCommand.Name);
94

95
  Get-Item -Path (Resolve-Path -Path $inputPath -Relative) | ForEach-Object {
96
    Write-Host ("{0}: hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh`n" -f $MyInvocation.MyCommand.Name);
97
    # $global:orgBaseName = $_.BaseName;
98
    $newName = $_.BaseName + $suffix + $_.Extension;
99
    Rename-Item -Path $_.FullName -NewName $newName;
100
  };
101
  Get-Item -Path (Resolve-Path -Path $outputPath -Relative) | ForEach-Object {
102
    Write-Host ("{0}: iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii`n" -f $MyInvocation.MyCommand.Name);
103
    $newName = $orgFileName;
104
    Rename-Item -Path $_.FullName -NewName $newName;
105
  };
106

107
  Write-Output $orgFileName;
108
  Write-Host ("{0}: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`n" -f $MyInvocation.MyCommand.Name);
109

110
  return $true;
111
}
112

113
$suffix = "_org";
114
Set-ImageOrientations $suffix;
115

116
$tmp = Read-Host "Input 'y' if you wanna move original images......";
117
$suffixWithExt = ".\*{0}.jpg" -f $suffix;
118
If ($tmp -eq "y") {
119
  # Move-Item -Path .\*_org.jpg -Destination .\5_original_files;
120
  Move-Item -Path $suffixWithExt -Destination .\5_original_files;
121
}

1
function Invoke-ExternalCommand([string]$commandPath, [string]$arguments) {
2
  try {
3
    # Creating process object.
4
    $pinfo = New-Object System.Diagnostics.Process
5
    # Setting process invocation parameters.
6
    $pinfo.StartInfo.FileName = $commandPath
7
    $pinfo.StartInfo.Arguments = $arguments
8
    $pinfo.StartInfo.UseShellExecute = $false
9
    $pinfo.StartInfo.CreateNoWindow = $true
10
    $pinfo.StartInfo.UseShellExecute = $false
11
    $pinfo.StartInfo.RedirectStandardOutput = $true
12
    $pinfo.StartInfo.RedirectStandardError = $true
13

14
    # Async Writing: Start
15
    # Creating string builders to store stdout and stderr.
16
    $oStdOutBuilder = New-Object -TypeName System.Text.StringBuilder
17
    $oStdErrBuilder = New-Object -TypeName System.Text.StringBuilder
18

19
    # Adding event handers for stdout and stderr.
20
    $sScripBlock = {
21
      if (! [String]::IsNullOrEmpty($EventArgs.Data)) {
22
        $Event.MessageData.AppendLine($EventArgs.Data)
23
      }
24
    }
25
    $oStdOutEvent = Register-ObjectEvent -InputObject $pinfo `
26
      -Action $sScripBlock -EventName 'OutputDataReceived' `
27
      -MessageData $oStdOutBuilder
28
    $oStdErrEvent = Register-ObjectEvent -InputObject $pinfo `
29
      -Action $sScripBlock -EventName 'ErrorDataReceived' `
30
      -MessageData $oStdErrBuilder
31

32
    # Starting process.
33
    [Void]$pinfo.Start()
34
    $pinfo.BeginOutputReadLine()
35
    $pinfo.BeginErrorReadLine()
36
    [Void]$pinfo.WaitForExit()
37
    # Async Writing: End
38

39
    # Unregistering events to retrieve process output.
40
    Unregister-Event -SourceIdentifier $oStdOutEvent.Name
41
    Unregister-Event -SourceIdentifier $oStdErrEvent.Name
42

43
    $oResult = New-Object -TypeName PSObject -Property ([Ordered]@{
44
        "ExitCode" = $pinfo.ExitCode;
45
        "stdout"   = $oStdOutBuilder.ToString().Trim();
46
        "stderr"   = $oStdErrBuilder.ToString().Trim();
47
      })
48
    return $oResult
49
  }
50
  finally {
51
    $pinfo.Dispose()
52
  }
53
}