June 18, 2019, 07:16:53 PM

Author Topic: RTCWHQ: AI Image upscaling with ESRGAN  (Read 108 times)

Offline Krischan

  • Full Member
  • ***
  • Posts: 197
    • Krischan's Homepage
RTCWHQ: AI Image upscaling with ESRGAN
« on: May 04, 2019, 04:09:49 PM »
Did you ever heard about ESRGAN? It is a new method written in Python using neural network machine learning to upscale lores images into 4x hires images on the GPU with CUDA. It is using a pretrained model and the results are really stunning. For example, I've created a HQ version of Return to Castle Wolfenstein (RTCW) and Wolfenstein: Enemy Territory (ET) and created a github repository with all tools I've written and used. Included is a small tool written in Blitzmax to upscale the alpha channel of 32bit TGAs, too. It only works on a nVidia card and the VRAM should be at least 8GB! ESRGAN can run on CPU but it is incredible slow. Limitations are that the texture input size must be below 1024x640 on 8GB VRAM or it won't work. But the best results are achieved with smaller images, with 64, 128, 256 or 512 size.

I've automated the whole process and optimized it to work with RTCW/ET PK3 files as input but it can be used for other purposes, too. Take a look a my new github repository for more details and a lot of background information: RTCWHQ



Original Texture (256x256) vs. upscaled Texture (1024x1024):


Original Alpha Texture (64x64) vs. upscaled Alpha Texture (256x256)


Ingame Screenshots:




So how is it done? You first need some prerequisites and RTCWHQ. Setting up Python is a bit tricky. You first need to install Python and add some libs to it before you can run the scripts. I hope I'll remember this correct:

1. download Python 3.7 (use the Windows x86-64 executable installer which adds the PATH variables)
2. install the CUDA toolkit
3. go to the Pytorch website and select Stable/Windows/PIP/Python 3.7/CUDA 10.0
4. run the two commands shown below the selection box in a commandline window
5. run this command too: pip3 install numpy opencv-python

This installs Python, pytorch, numpy and opencv which are necessary to run RTCWHQ. You can use this method to upscale any kind of images, icons, textures or whatever. There are many models out there and you can even train your own models to achieve even better results but this is rocket science. I've been happy with the model provided in my repository as the results are already sufficient to me.

Thanks to Brucey for the great freeimage.mod. I'd prefer a complete python solution but my tool also works very reliably. Here is the source:
Code: BlitzMax
  1. SuperStrict
  2.  
  3. Framework brl.basic
  4.  
  5. Import brl.Pixmap
  6. Import brl.retro
  7. Import brl.eventqueue
  8. Import brl.DirectSoundAudio
  9. Import brl.oggloader
  10. Import pub.freeprocess
  11. Import bah.freeimage
  12.  
  13. IncBin "cuckoo.ogg"
  14.  
  15. Global sca:Int = 4           ' scale factor
  16. Global blu:Int = 4           ' gaussian blur
  17. Global con:Float = 0.0       ' contrast fix
  18. Global bri:Float = 0.0       ' brightness fix
  19. Global aut:Int = True        ' autolimbo feature
  20. Global dir:String = ""       ' directory to parse
  21. Global cnt:Int = 0           ' file counter
  22. Global ver:String = "RTCW/ET Upscaler Version 1.0 by Krischan"
  23.  
  24. If AppArgs.Length > 1 Then
  25.  
  26.         If AppArgs[1] Then dir = String(AppArgs[1])
  27.                                        
  28. End If
  29.  
  30. If dir = "" Or dir = "/?" Then ConsoleDefault()
  31.  
  32. If AppArgs.Length > 2 Then
  33.  
  34.         If AppArgs[2] > 0 Then sca = Int(AppArgs[2])
  35.  
  36. End If
  37.  
  38. If AppArgs.Length > 3 Then
  39.  
  40.         If AppArgs[3] > 0 Then blu = Int(AppArgs[3])
  41.  
  42. End If
  43.  
  44. If AppArgs.Length > 4 Then
  45.  
  46.         If AppArgs[4] > 0 Then con = Float(AppArgs[4])
  47.  
  48. End If
  49.  
  50. If AppArgs.Length > 5 Then
  51.  
  52.         If AppArgs[5] Then bri = Float(AppArgs[5])
  53.  
  54. End If
  55.  
  56. If AppArgs.Length > 6 Then
  57.  
  58.         If AppArgs[6] Then aut = Float(AppArgs[6])
  59.  
  60. End If
  61.  
  62. Global sound:TSound = LoadSound("incbin::cuckoo.ogg")
  63. Global channel:TChannel = AllocChannel()
  64.  
  65. ' start the action
  66. Print ver
  67. Print "Gaussian Blur: " + blu + " Pixels"
  68. Print "Brightness:    " + bri
  69. Print "Contrast:      " + con
  70.  
  71. ' convert alpha channels
  72. ConvertAlpha(dir)
  73. Print "Converted " + cnt + " images. Done. Have fun :)"
  74.  
  75. ' play sound and end
  76. CueSound(sound, channel)
  77. PlaySound(sound, channel)
  78. Delay 1000
  79. End
  80.  
  81. ' ----------------------------------------------------------------------------
  82. ' Read current Directory
  83. ' ----------------------------------------------------------------------------
  84. Function ConvertAlpha:Int(dir:String)
  85.  
  86.         Local path:Int
  87.         Local filename:String
  88.        
  89.         Local prefix:String
  90.         Local ext:String
  91.         Local full:String
  92.        
  93.         'dir = Lower(dir)
  94.         path = ReadDir(dir)
  95.         If Not path Return False
  96.        
  97.         Repeat
  98.                
  99.                 ' get next filename
  100.                 filename = NextFile(path)
  101.                 full = dir + "/" + filename
  102.                 ext = Lower(ExtractExt(filename))
  103.                 prefix = Replace(filename, "." + ext, "")
  104.                                                        
  105.                 ' skip dotted dirs
  106.                 If filename = "." Or filename = ".." Or filename = "" Then Continue
  107.        
  108.                 ' dir? parse recursively
  109.                 If FileType(dir + "/" + filename) = FILETYPE_DIR Then ConvertAlpha(dir + "/" + filename)
  110.        
  111.                 ' only parse the unscaled images
  112.                 If ext = "png" And (Not Instr(Lower(filename), "[s]")) Then
  113.                
  114.                         ' load unscaled image
  115.                         Local pixmap:TPixmap = LoadPixmap(full)
  116.                        
  117.                         'pixmap = ConvertPixmap(pixmap, PF_RGBA8888)
  118.                         Local w:Int = pixmap.width
  119.                         Local h:Int = pixmap.Height
  120.                        
  121.                         ' load scaled image
  122.                         Local scaled:TPixmap = LoadPixmap(dir + "/" + prefix + " [S]." + ext)
  123.                        
  124.                         If (TPixmap(scaled)) Then
  125.                        
  126.                                 ' texture has an alpha channel?
  127.                                 If pixmap.format = 5 Then
  128.                                
  129.                                         ' scale and blur
  130.                                         pixmap = ResizePixmap(pixmap, w * sca, h * sca)
  131.                                         pixmap = GaussianBlur(pixmap, blu)
  132.                                        
  133.                                         ' adjust alpha channel and combine with scaled image RGBs
  134.                                         For Local x:Int = 0 To w * sca - 1
  135.                                        
  136.                                                 For Local y:Int = 0 To h * sca - 1
  137.                                                
  138.                                                         Local rgb:Int = ReadPixel(pixmap, x, y)
  139.                                                         Local a:Int = GetA(rgb)
  140.                                                         Local c:Int = a
  141.                                                        
  142.                                                         ' auto contrast for gfx folder (limbo icons)
  143.                                                         If aut And Instr(dir, "gfx/") Then bri = 0 ; con = 0.5
  144.                                                        
  145.                                                         ' adjust brightness and contrast
  146.                                                         c = Brightness(c, bri)
  147.                                                         c = Contrast(a, con)
  148.                                                        
  149.                                                         ' get RGB pixels
  150.                                                         rgb = ReadPixel(scaled, x, y)
  151.                                                         Local r:Int = getR(rgb)
  152.                                                         Local g:Int = getG(rgb)
  153.                                                         Local b:Int = getB(rgb)
  154.                                                        
  155.                                                         ' create final RGB value with alpha channel
  156.                                                         rgb = CombineRGBA(r, g, b, c)
  157.                                                        
  158.                                                         ' only write pixel if within image bounds
  159.                                                         If x < (w * sca) And y < (h * sca) Then WritePixel(pixmap, x, y, rgb)
  160.                                                
  161.                                                 Next
  162.                                                
  163.                                         Next
  164.                                        
  165.                                         ' save 24bit JPEG
  166.                                         'If Instr(prefix, ".jpg") Then
  167.                                        
  168.                                         '       Print "Converted 24bit JPEG: " + dir + Replace(prefix, ".jpg", "") + ".jpg"
  169.                                         '       Local img:TFreeImage = TFreeImage.CreateFromPixmap(pixmap)
  170.                                         '       img.Save(dir + Replace(prefix, ".jpg", "") + ".jpg", FIF_JPEG, JPEG_QUALITYSUPERB)
  171.                                         '       cnt:+1
  172.                                         '       img = Null
  173.                                                
  174.                                         ' save 32bit TGA
  175.                                         'Else
  176.                                        
  177.                                                 Print "Converted 32bit TGA: " + dir + "/" + prefix
  178.                                                 SavePixmapTGA(pixmap, dir + "/" + prefix, 32)
  179.                                                 cnt:+1
  180.                                                 pixmap = Null
  181.                                        
  182.                                         'EndIf
  183.                
  184.                                 Else
  185.                                
  186.                                         ' save 24bit JPEG
  187.                                         If Instr(prefix, ".jpg") Then
  188.                                        
  189.                                                 Print "Converted 24bit JPEG: " + dir + Replace(prefix, ".jpg", "") + ".jpg"
  190.                                                 Local img:TFreeImage = TFreeImage.CreateFromPixmap(scaled)
  191.                                                 img.Save(dir + "/" + Replace(prefix, ".jpg", "") + ".jpg", FIF_JPEG, JPEG_QUALITYSUPERB)
  192.                                                 cnt:+1
  193.                                                 img = Null
  194.                                        
  195.                                         ' save 24bit TGA
  196.                                         Else
  197.                                
  198.                                                 Print "Converted 24bit TGA: " + dir + "/" + prefix
  199.                                                 SavePixmapTGA(scaled, dir + "/" + prefix, 24)
  200.                                                 cnt:+1
  201.                                                 pixmap = Null
  202.                                                
  203.                                         EndIf
  204.                                
  205.                                 EndIf
  206.                                
  207.                         EndIf
  208.                        
  209.                         scaled = Null
  210.                         GCCollect()
  211.                        
  212.                         ' delete original and temporarly used files
  213.                         DeleteFile(full)
  214.                         DeleteFile(dir + "/" + prefix + " [S]." + ext)
  215.                
  216.                 EndIf
  217.                
  218.         Until filename = ""
  219.                        
  220.         ' close dir
  221.         CloseDir path
  222.                        
  223.         Return True
  224.                
  225. End Function
  226.  
  227.  
  228.  
  229. ' ----------------------------------------------------------------------------
  230. ' Adjust Brightness of a RGB value
  231. ' ----------------------------------------------------------------------------
  232. Function Brightness:Int(c:Int, factor:Float)
  233.  
  234.         c = c + (255 * factor)
  235.         If c < 0 Then c = 0 Else If c > 255 Then c = 255
  236.         Return c
  237.  
  238. End Function
  239.  
  240.  
  241. ' ----------------------------------------------------------------------------
  242. ' Adjust Contrast of a RGB value
  243. ' ----------------------------------------------------------------------------
  244. Function Contrast:Int(c:Int, factor:Float)
  245.  
  246.         Local contrast:Int = 255 * factor
  247.         Local f:Int = (259 * (contrast + 255)) / (255 * (259 - contrast))
  248.        
  249.         c = (f * (c - 128)) + 128
  250.         If c < 0 Then c = 0 Else If c > 255 Then c = 255
  251.        
  252.         Return c
  253.  
  254. End Function
  255.  
  256.  
  257.  
  258. ' ----------------------------------------------------------------------------
  259. ' Return A value of a given RGB value
  260. ' ----------------------------------------------------------------------------
  261. Function GetA:Int(RGB:Int)
  262.        
  263.         Return RGB Shr 24 & %11111111
  264.        
  265. End Function
  266.  
  267.  
  268.  
  269. ' ----------------------------------------------------------------------------
  270. ' Return R value of a given RGB value
  271. ' ----------------------------------------------------------------------------
  272. Function GetR:Int(RGB:Int)
  273.        
  274.         Return RGB Shr 16 & %11111111
  275.        
  276. End Function
  277.  
  278.  
  279.  
  280. ' ----------------------------------------------------------------------------
  281. ' Return G value of a given RGB value
  282. ' ----------------------------------------------------------------------------
  283. Function GetG:Int(RGB:Int)
  284.        
  285.         Return RGB Shr 8 & %11111111
  286.        
  287. End Function
  288.  
  289.  
  290.  
  291. ' ----------------------------------------------------------------------------
  292. ' Return B value of a given RGB value
  293. ' ----------------------------------------------------------------------------
  294. Function GetB:Int(RGB:Int)
  295.        
  296.         Return RGB & %11111111
  297.        
  298. End Function
  299.  
  300.  
  301.  
  302. ' ----------------------------------------------------------------------------
  303. ' Return ARGB value of given R,G,B,A single values
  304. ' ----------------------------------------------------------------------------
  305. Function CombineRGBA:Int(r:Int, g:Int, b:Int, a:Int)
  306.  
  307.         Return b | (g Shl 8) | (r Shl 16) | (a Shl 24)
  308.        
  309. End Function
  310.  
  311.  
  312.  
  313. ' ----------------------------------------------------------------------------
  314. ' Return RGB value of given R,G,B single values
  315. ' ----------------------------------------------------------------------------
  316. Function CombineRGB:Int(r:Int, g:Int, b:Int)
  317.  
  318.         Return b | (g Shl 8) | (r Shl 16)
  319.        
  320. End Function
  321.  
  322.  
  323.  
  324. ' ----------------------------------------------------------------------------
  325. ' Saves a Pixmap to a TGA File (32bit depth only!)
  326. ' ----------------------------------------------------------------------------
  327. Function SavePixmapTGA(pixmap:TPixmap, filename:String, depth:Int = 32, onlyalpha:Int = False)
  328.  
  329.         Local width:Int = pixmap.width
  330.         Local Height:Int = pixmap.Height
  331.         Local rgb:Int
  332.         Local a:Int
  333.         Local att:Int = 8
  334.        
  335.         Local x:Int, y:Int
  336.        
  337.         Local f:TStream = WriteFile(filename)
  338.        
  339.         If onlyalpha Then depth = 24
  340.        
  341.         WriteByte(f, 0) 'idlength
  342.         WriteByte(f, 0) 'colormaptype
  343.         WriteByte(f, 2) 'imagetype 2=rgb
  344.         WriteShort(f, 0) 'colormapindex
  345.         WriteShort(f, 0) 'colormapnumentries
  346.         WriteByte(f, 0) 'colormapsize
  347.         WriteShort(f, 0) 'xorigin
  348.         WriteShort(f, 0) 'yorigin
  349.         WriteShort(f, width) 'width
  350.         WriteShort(f, Height) 'height
  351.         WriteByte(f, depth) 'pixsize
  352.         WriteByte(f, att) 'attributes
  353.        
  354.         For y = Height - 1 To 0 Step - 1
  355.        
  356.                 For x = 0 To width - 1
  357.                
  358.                         rgb = ReadPixel(pixmap, x, y)
  359.                        
  360.                         If onlyalpha Then
  361.                        
  362.                                 a = GetA(rgb)
  363.                                 WriteByte(f, a)
  364.                                 WriteByte(f, a)
  365.                                 WriteByte(f, a)
  366.                                
  367.                         Else
  368.                        
  369.                                 If depth = 24 Then
  370.                                
  371.                                         WriteByte(f, GetB(rgb))
  372.                                         WriteByte(f, GetG(rgb))
  373.                                         WriteByte(f, GetR(rgb))
  374.  
  375.                                 Else
  376.                                                        
  377.                                         WriteInt(f, rgb)
  378.                                        
  379.                                 EndIf
  380.                        
  381.                         EndIf
  382.  
  383.                 Next
  384.         Next
  385.        
  386.         CloseFile f
  387.                
  388. End Function
  389.  
  390.  
  391.  
  392. ' ----------------------------------------------------------------------------
  393. ' Gaussian Blur Call
  394. ' ----------------------------------------------------------------------------
  395. Function GaussianBlur:TPixmap(tex:TPixmap, radius:Int)
  396.  
  397.         If radius <= 0 Return tex
  398.        
  399.         'clone incoming texture
  400.         Local texclone:TPixmap = tex.Copy()
  401.        
  402.         'instantiate a new gaussian filter
  403.         Local filter:TGaussianFilter = New TGaussianFilter
  404.        
  405.         'configure it
  406.         Filter.radius = radius
  407.        
  408.         Return Filter.Apply(tex, texclone)
  409.        
  410. End Function
  411.  
  412.  
  413.  
  414. ' ----------------------------------------------------------------------------
  415. ' Gaussian Blur Type
  416. ' ----------------------------------------------------------------------------
  417. Type TGaussianFilter
  418.  
  419.         Field radius:Double
  420.         Field kernel:TKernel
  421.        
  422.         ' apply Gaussian Blur to pixmap
  423.         Method Apply:TPixmap(src:TPixmap, dst:TPixmap)
  424.        
  425.                 Self.kernel = makekernel(Self.radius)
  426.                 Self.convolveAndTranspose(Self.kernel, src, dst, PixmapWidth(src), PixmapHeight(src), True)
  427.                 Self.convolveAndTranspose(Self.kernel, dst, src, PixmapHeight(dst), PixmapWidth(dst), True)
  428.  
  429.                 dst = Null
  430.  
  431.                 GCCollect()
  432.  
  433.                 Return src
  434.  
  435.         End Method
  436.  
  437.         ' Make a Gaussian blur kernel
  438.         Method makekernel:TKernel(radius:Double)
  439.        
  440.                 Local r:Int = Int(Ceil(radius))
  441.                 Local rows:Int = r * 2 + 1
  442.                 Local matrix:Double[] = New Double[rows]
  443.                 Local sigma:Double = radius / 3.0
  444.                 Local sigma22:Double = 2 * sigma * sigma
  445.                 Local sigmaPi2:Double = 2 * Pi * sigma
  446.                 Local sqrtSigmaPi2:Double = Double(Sqr(sigmaPi2))
  447.                 Local radius2:Double = radius * radius
  448.                 Local total:Double = 0
  449.                 Local index:Int = 0
  450.  
  451.                 For Local row:Int = -r To r
  452.  
  453.                         Local distance:Double = Double(row * row)
  454.        
  455.                         If (distance > radius2) Then
  456.        
  457.                                 matrix[index] = 0
  458.  
  459.                         Else
  460.        
  461.                                 matrix[index] = Double(Exp(-(distance / sigma22)) / sqrtSigmaPi2)
  462.                                 total:+matrix[index]
  463.                                 index:+1
  464.  
  465.                         End If
  466.        
  467.                 Next
  468.  
  469.                 For Local i:Int = 0 Until rows
  470.  
  471.                         'normalizes the gaussian kernel
  472.                         matrix[i] = matrix[i] / total
  473.        
  474.                 Next
  475.  
  476.                 Return mkernel(rows, 1, matrix)
  477.  
  478.         End Method
  479.        
  480.         ' return function for makekernel
  481.         Function mkernel:TKernel(w:Int, h:Int, d:Double[])
  482.        
  483.                 Local k:TKernel = New TKernel
  484.  
  485.                 k.width = W
  486.                 k.Height = H
  487.                 k.data = d
  488.        
  489.                 Return k
  490.  
  491.         End Function
  492.  
  493.         ' Convolve Gaussian Blur
  494.         Method ConvolveAndTranspose(kernel:TKernel, in:TPixmap, out:TPixmap, width:Int, Height:Int, Alpha:Int)
  495.        
  496.                 Local inba:Byte Ptr = in.Pixels
  497.                 Local outba:Byte Ptr = out.Pixels
  498.  
  499.                 Local matrix:Double[] = kernel.getKernelData()
  500.  
  501.                 Local cols:Int = kernel.GetWidth()
  502.                 Local cols2:Int = cols / 2
  503.  
  504.                 For Local y:Int = 0 Until Height
  505.  
  506.                         Local index:Int = y
  507.        
  508.                         Local ioffset:Int = y * width
  509.        
  510.                         For Local x:Int = 0 Until width
  511.  
  512.                                 Local r:Double = 0, g:Double = 0, b:Double = 0, a:Double = 0
  513.                                 Local moffset:Int = cols2
  514.        
  515.                                 For Local col:Int = -cols2 To cols2
  516.        
  517.                                         Local f:Double = matrix[moffset + col]
  518.        
  519.                                         If (f <> 0) Then
  520.  
  521.                                                 Local ix:Int = x + col
  522.  
  523.                                                 If (ix < 0) Then
  524.        
  525.                                                         ix = 0
  526.  
  527.                                                 Else If (ix >= width)
  528.        
  529.                                                         ix = width - 1
  530.  
  531.                                                 End If
  532.        
  533.                                                 Local rgb:Int = (Int Ptr inba)[ioffset + ix]
  534.                                                 a:+f * ((rgb Shr 24) & $FF)
  535.                                                 'b:+f * ((rgb Shr 16) & $FF)
  536.                                                 'g:+f * ((rgb Shr 8) & $FF)
  537.                                                 'r:+f * (rgb & $FF)
  538.  
  539.                                         End If
  540.  
  541.                 Next
  542.  
  543.                 Local ia:Int
  544.  
  545.                 If Alpha = True Then ia = ClampColor(Int(a + 0.5)) Else ia = $FF
  546.  
  547.                 'Local ir:Int = ClampColor(Int(r + 0.5))
  548.                 'Local ig:Int = ClampColor(Int(g + 0.5))
  549.                 'Local ib:Int = ClampColor(Int(b + 0.5))
  550.  
  551.                 (Int Ptr outba)[index] = (ia Shl 24)' | (ib Shl 16) | (ig Shl 8) | (ir Shl 0))
  552.  
  553.                 index:+Height
  554.  
  555.                 Next
  556.        
  557.                 Next
  558.  
  559.         End Method
  560.        
  561. End Type
  562.  
  563.  
  564.  
  565.  
  566. ' ----------------------------------------------------------------------------
  567. ' Gaussian Blur Kernel
  568. ' ----------------------------------------------------------------------------
  569. Type TKernel
  570.  
  571.         Field width:Int
  572.         Field Height:Int
  573.         Field data:Double[]
  574.        
  575.         Method getkerneldata:Double[] ()
  576.        
  577.                 Return Self.data
  578.  
  579.         End Method
  580.        
  581.         Method GetWidth:Int()
  582.        
  583.                 Return Self.width
  584.  
  585.         End Method
  586.        
  587.         Method GetHeight:Int()
  588.        
  589.                 Return Self.Height
  590.  
  591.         End Method
  592.  
  593. End Type
  594.  
  595.  
  596.  
  597. ' ----------------------------------------------------------------------------
  598. ' Clamp a value to a given range
  599. ' ----------------------------------------------------------------------------
  600. Function Clamp:Int(val:Int, minimum:Int, maximum:Int)
  601.  
  602.         If val < minimum
  603.        
  604.                 Return minimum
  605.  
  606.         ElseIf val > maximum
  607.        
  608.                 Return maximum
  609.  
  610.         Else
  611.        
  612.                 Return val
  613.  
  614.         EndIf
  615.  
  616. End Function
  617.  
  618.  
  619.  
  620. ' ----------------------------------------------------------------------------
  621. ' Clamp a RGB value to 0...255
  622. ' ----------------------------------------------------------------------------
  623. Function ClampColor:Int(val:Int)
  624.  
  625.         If val < 0
  626.        
  627.                 Return 0
  628.  
  629.         ElseIf val > 255
  630.        
  631.                 Return 255
  632.  
  633.         Else
  634.        
  635.                 Return val
  636.  
  637.         EndIf
  638.  
  639. End Function
  640.  
  641.  
  642.  
  643. ' ----------------------------------------------------------------------------
  644. ' Default Console output with help and infos about this tool
  645. ' ----------------------------------------------------------------------------
  646. Function ConsoleDefault()
  647.  
  648.         Print "==============================================================================="
  649.         Print ver
  650.         Print "==============================================================================="
  651.         Print "Scales TGA32 images with Alpha Channels by factor 4 with a bilinear filter,    "
  652.         Print "blurs them with a Gaussian blur filter, applies a brightness/contrast fix and  "
  653.         Print "recombines them with a prescaled PNG image. The original image is then replaced"
  654.         Print "by the scaled version with the optimized Alpha channel.                        "
  655.         Print "==============================================================================="
  656.         Print
  657.         Print "Usage:   convert.exe /? displays this help                                     "
  658.         Print "Usage:   convert.exe [input] [scale] [contrast] [brightness] [autolimbo]       "
  659.         Print "Example: convert.exe input 4 4 0.5 0    (general defaults for RTCW/ET textures)"
  660.         Print "Example: convert.exe input 4 32 0.9 -0.75  (high contrast for very sharp edges)"
  661.         Print
  662.         Print "Parameters:"
  663.         Print "[input]      Folder to parse (mandatory!)             (empty, for ex. input)   "
  664.         Print "[scale]      optional: Scale Factor, depends on model (Default: 4)      integer"
  665.         Print "[blur]       optional: Alphamap Gaussian Blur         (Default: 4)      integer"
  666.         Print "[contrast]   optional: Alphamap Contrast change       (Default: 0.0)      float"
  667.         Print "[brightness] optional: Alphamap Brightness change     (Default: 0.0)      float"
  668.         Print "[autolimbo]  optional: contrast=0.5 for gfx/ files    (Default: 1)      integer"
  669.         Print "==============================================================================="
  670.         Print
  671.         End
  672.  
  673. End Function

Oh, and if you're a fan of ET like me stay tuned for my final ETlaunch tool to launch ET custom maps. It is part of a larger project (ETSE - Enemy Territory Special Edition) which is a complete HQ version of Enemy Territory using ETlegacy with HQ Textures, HQ GUI, NQ Mod, nice additions and up to 64 bots. Now you can play ET as a "single player" against dumb and evil bots. Of course written in Blitzmax ;D
Kind regards
Krischan

Windows 10 Pro | i7 9700K@ 3.6GHz | RTX 2080 8GB]
My Blitzbasic Archive | Extrasolar Project | My Github projects

Offline Qube

  • Administrator
  • Hero Member
  • *****
  • Posts: 1901
Re: RTCWHQ: AI Image upscaling with ESRGAN
« Reply #1 on: May 04, 2019, 05:47:56 PM »
Looks pretty cool. As I'm lazy, is there a tool whereby I can just give it an image, set the scale and it spits out the result without me having to install / configure loads of things?
Until the next time...

Offline Krischan

  • Full Member
  • ***
  • Posts: 197
    • Krischan's Homepage
Re: RTCWHQ: AI Image upscaling with ESRGAN
« Reply #2 on: May 04, 2019, 06:12:36 PM »
Yeah, but costs 99 bucks: Topaz Gigapixel. But the results are not as good as ESRGAN IMHO, that's why I didn't buy it though I considered it.

And hey, I spent a lot of time to AUTOMATE the process, so I can demand that you take a look at it at least once. :))
Kind regards
Krischan

Windows 10 Pro | i7 9700K@ 3.6GHz | RTX 2080 8GB]
My Blitzbasic Archive | Extrasolar Project | My Github projects