Archives/GIMP-ML
2
0
Fork 0
mirror of https://github.com/kritiksoman/GIMP-ML synced 2024-10-31 09:20:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

CPUButton

Browse Source
This commit is contained in:
Kritik Soman 2020-09-20 18:55:54 +05:30
parent 68f6269355
commit 001b95d59d
16 changed files with 117 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
gimp-plugins/CelebAMask-HQ/MaskGAN_demo/models/networks.py Normal file → Executable file
View File

@ -38,9 +38,9 @@ def define_G(input_nc, output_nc, ngf, netG, n_downsample_global=3, n_blocks_glo
else:
raise('generator not implemented!')
print(netG)
# if len(gpu_ids) > 0:
# assert(torch.cuda.is_available())
# netG.cuda(gpu_ids[0])
if len(gpu_ids) > 0:
assert(torch.cuda.is_available())
netG.cuda(gpu_ids[0])
netG.apply(weights_init)
return netG

8
gimp-plugins/CelebAMask-HQ/MaskGAN_demo/models/pix2pixHD_model.py Normal file → Executable file
View File

@ -184,7 +184,7 @@ class Pix2PixHDModel(BaseModel):
return inter_label_1, input_label, inter_label_2, real_image, input_label_ref, real_image_ref
def encode_input_test(self, label_map, label_map_ref, real_image_ref, infer=False):
def encode_input_test(self, label_map, label_map_ref, real_image_ref, infer=False,f=False):
if self.opt.label_nc == 0:
if torch.cuda.is_available():
@ -198,7 +198,7 @@ class Pix2PixHDModel(BaseModel):
# create one-hot vector for label map
size = label_map.size()
oneHot_size = (size[0], self.opt.label_nc, size[2], size[3])
if torch.cuda.is_available():
if torch.cuda.is_available() and not f:
input_label = torch.cuda.FloatTensor(torch.Size(oneHot_size)).zero_()
input_label = input_label.scatter_(1, label_map.data.long().cuda(), 1.0)
input_label_ref = torch.cuda.FloatTensor(torch.Size(oneHot_size)).zero_()
@ -280,11 +280,11 @@ class Pix2PixHDModel(BaseModel):
# Only return the fake_B image if necessary to save BW
return [ self.loss_filter( loss_G_GAN, loss_G_GAN_Feat, loss_G_VGG, loss_GB_GAN, loss_GB_GAN_Feat, loss_GB_VGG, loss_D_real, loss_D_fake, loss_D_blend ), None if not infer else fake_inter_1, fake_image, fake_inter_2, blend_image, alpha, real_image, inter_label_1, input_label, inter_label_2 ]
def inference(self, label, label_ref, image_ref):
def inference(self, label, label_ref, image_ref,cFlag):
# Encode Inputs
image_ref = Variable(image_ref)
input_label, input_label_ref, real_image_ref = self.encode_input_test(Variable(label), Variable(label_ref), image_ref, infer=True)
input_label, input_label_ref, real_image_ref = self.encode_input_test(Variable(label), Variable(label_ref), image_ref, infer=True,f=cFlag)
if torch.__version__.startswith('0.4'):
with torch.no_grad():

8
gimp-plugins/DeblurGANv2/predictorClass.py Normal file → Executable file
View File

@ -25,11 +25,11 @@ config = {'project': 'deblur_gan', 'warmup_num': 3, 'optimizer': {'lr': 0.0001,
class Predictor:
def __init__(self, weights_path, model_name=''):
def __init__(self, weights_path, model_name='',cf=False):
# model = get_generator(model_name or config['model'])
model = get_generator_new(weights_path[0:-11])
model.load_state_dict(torch.load(weights_path, map_location=lambda storage, loc: storage)['model'])
if torch.cuda.is_available():
if torch.cuda.is_available() and not cf:
self.model = model.cuda()
else:
self.model = model
@ -73,10 +73,10 @@ class Predictor:
x = (np.transpose(x, (1, 2, 0)) + 1) / 2.0 * 255.0
return x.astype('uint8')
def __call__(self, img, mask, ignore_mask=True):
def __call__(self, img, mask, ignore_mask=True,cf=False):
(img, mask), h, w = self._preprocess(img, mask)
with torch.no_grad():
if torch.cuda.is_available():
if torch.cuda.is_available() and not cf:
inputs = [img.cuda()]
else:
inputs = [img]

10
gimp-plugins/MiDaS/run.py Normal file → Executable file
View File

@ -11,7 +11,7 @@ import cv2
# import imageio
def run_depth(img, model_path, Net, utils, target_w=None):
def run_depth(img, model_path, Net, utils, target_w=None,f=False):
"""Run MonoDepthNN to compute depth maps.
Args:
@ -22,12 +22,13 @@ def run_depth(img, model_path, Net, utils, target_w=None):
# print("initialize")
# select device
device = torch.device("cpu")
# device = torch.device("cpu")
# print("device: %s" % device)
# load network
model = Net(model_path)
model.to(device)
if torch.cuda.is_available() and not f:
model.cuda()
model.eval()
# get input
@ -50,7 +51,8 @@ def run_depth(img, model_path, Net, utils, target_w=None):
target_height, target_width = int(round(img.shape[0] * scale)), int(round(img.shape[1] * scale))
img_input = utils.resize_image(img)
# print(img_input.shape)
img_input = img_input.to(device)
if torch.cuda.is_available() and not f:
img_input = img_input.cuda()
# compute
with torch.no_grad():
out = model.forward(img_input)

22
gimp-plugins/deblur.py
View File

@ -9,6 +9,7 @@ sys.path.extend([baseLoc+'gimpenv/lib/python2.7',baseLoc+'gimpenv/lib/python2.7/
import cv2
from predictorClass import Predictor
import numpy as np
import torch
def channelData(layer):#convert gimp image to numpy
region=layer.get_pixel_rgn(0, 0, layer.width,layer.height)
@ -25,17 +26,21 @@ def createResultLayer(image,name,result):
image.add_layer(rl,0)
gimp.displays_flush()
def getdeblur(img):
predictor = Predictor(weights_path=baseLoc+'weights/deblur/'+'best_fpn.h5')
def getdeblur(img,flag):
predictor = Predictor(weights_path=baseLoc+'weights/deblur/'+'best_fpn.h5',cf=flag)
if img.shape[2] == 4: # get rid of alpha channel
img = img[:,:,0:3]
pred = predictor(img, None)
img = img[:,:,0:3]
pred = predictor(img, None,cf=flag)
return pred
def deblur(img, layer):
gimp.progress_init("Deblurring " + layer.name + "...")
def deblur(img, layer,flag):
if torch.cuda.is_available() and not flag:
gimp.progress_init("(Using GPU) Deblurring " + layer.name + "...")
else:
gimp.progress_init("(Using CPU) Deblurring " + layer.name + "...")
imgmat = channelData(layer)
pred = getdeblur(imgmat)
pred = getdeblur(imgmat,flag)
createResultLayer(img,'deblur_'+layer.name,pred)
@ -50,6 +55,9 @@ register(
"*", # Alternately use RGB, RGB*, GRAY*, INDEXED etc.
[ (PF_IMAGE, "image", "Input image", None),
(PF_DRAWABLE, "drawable", "Input drawable", None),
# (PF_LAYER, "drawinglayer", "Original Image", None),
(PF_BOOL, "fcpu", "Force CPU", False)
],
[],
deblur, menu="<Image>/Layer/GIML-ML")

7
gimp-plugins/deepcolor.py
View File

@ -24,7 +24,7 @@ def channelData(layer):#convert gimp image to numpy
return np.frombuffer(pixChars,dtype=np.uint8).reshape(layer.height,layer.width,bpp)
def deepcolor(tmp1, tmp2, ilayerimg,ilayerc) :
def deepcolor(tmp1, tmp2, ilayerimg,ilayerc,cflag) :
layerimg = channelData(ilayerimg)
layerc = channelData(ilayerc)
@ -47,7 +47,7 @@ def deepcolor(tmp1, tmp2, ilayerimg,ilayerc) :
if layerimg.shape[2] == 4: #remove alpha channel in image if present
layerimg = layerimg[:,:,0:3]
if torch.cuda.is_available():
if torch.cuda.is_available() and not cflag:
gimp.progress_init("(Using GPU) Running deepcolor for " + ilayerimg.name + "...")
gpu_id = 0
else:
@ -58,7 +58,7 @@ def deepcolor(tmp1, tmp2, ilayerimg,ilayerc) :
colorModel.prep_net(gpu_id, baseLoc + 'weights/colorize/caffemodel.pth')
colorModel.load_image(layerimg) # load an image
img_out = colorModel.net_forward(input_ab, mask) # run model, returns 256x256 image
img_out = colorModel.net_forward(input_ab, mask,f=cflag) # run model, returns 256x256 image
img_out_fullres = colorModel.get_img_fullres() # get image at full resolution
createResultLayer(tmp1, 'new_' + ilayerimg.name, img_out_fullres)
@ -78,6 +78,7 @@ register(
(PF_DRAWABLE, "drawable", "Input drawable", None),
(PF_LAYER, "drawinglayer", "Original Image:", None),
(PF_LAYER, "drawinglayer", "Color Mask:", None),
(PF_BOOL, "fcpu", "Force CPU", False)
],
[],
deepcolor, menu="<Image>/Layer/GIML-ML")

13
gimp-plugins/deepdehaze.py
View File

@ -14,13 +14,13 @@ import net
import numpy as np
import cv2
def clrImg(data_hazy):
def clrImg(data_hazy,cFlag):
data_hazy = (data_hazy / 255.0)
data_hazy = torch.from_numpy(data_hazy).float()
data_hazy = data_hazy.permute(2, 0, 1)
dehaze_net = net.dehaze_net()
if torch.cuda.is_available():
if torch.cuda.is_available() and not cFlag:
dehaze_net = dehaze_net.cuda()
dehaze_net.load_state_dict(torch.load(baseLoc+'weights/deepdehaze/dehazer.pth'))
data_hazy = data_hazy.cuda()
@ -31,7 +31,7 @@ def clrImg(data_hazy):
gimp.displays_flush()
data_hazy = data_hazy.unsqueeze(0)
clean_image = dehaze_net(data_hazy)
out = clean_image.detach().numpy()[0,:,:,:]*255
out = clean_image.detach().cpu().numpy()[0,:,:,:]*255
out = np.clip(np.transpose(out,(1,2,0)),0,255).astype(np.uint8)
return out
@ -53,15 +53,15 @@ def createResultLayer(image, name, result):
gimp.displays_flush()
def deepdehazing(img, layer):
if torch.cuda.is_available():
def deepdehazing(img, layer, cFlag):
if torch.cuda.is_available() and not cFlag:
gimp.progress_init("(Using GPU) Dehazing " + layer.name + "...")
else:
gimp.progress_init("(Using CPU) Dehazing " + layer.name + "...")
imgmat = channelData(layer)
if imgmat.shape[2] == 4: # get rid of alpha channel
imgmat = imgmat[:,:,0:3]
cpy = clrImg(imgmat)
cpy = clrImg(imgmat,cFlag)
createResultLayer(img, 'new_output', cpy)
@ -76,6 +76,7 @@ register(
"*", # Alternately use RGB, RGB*, GRAY*, INDEXED etc.
[(PF_IMAGE, "image", "Input image", None),
(PF_DRAWABLE, "drawable", "Input drawable", None),
(PF_BOOL, "fcpu", "Force CPU", False)
],
[],
deepdehazing, menu="<Image>/Layer/GIML-ML")

16
gimp-plugins/deepdenoise.py
View File

@ -12,7 +12,7 @@ sys.path.extend([baseLoc + 'gimpenv/lib/python2.7', baseLoc + 'gimpenv/lib/pytho
from denoiser import *
from argparse import Namespace
def clrImg(Img):
def clrImg(Img,cFlag):
w, h, _ = Img.shape
opt = Namespace(color=1, cond=1, delog='logsdc', ext_test_noise_level=None,
k=0, keep_ind=None, mode='MC', num_of_layers=20, out_dir='results_bc',
@ -25,7 +25,7 @@ def clrImg(Img):
device_ids = [0]
model = nn.DataParallel(net, device_ids=device_ids)
model_est = nn.DataParallel(est_net, device_ids=device_ids)# Estimator Model
if torch.cuda.is_available():
if torch.cuda.is_available() and not cFlag:
ckpt_est = torch.load(baseLoc+'weights/deepdenoise/est_net.pth')
ckpt = torch.load(baseLoc+'weights/deepdenoise/net.pth')
model = model.cuda()
@ -57,6 +57,8 @@ def clrImg(Img):
merge_out = np.zeros([w, h, 3])
wbin = opt.wbin
i = 0
idx=0
t=(w*h)/(wbin*wbin)
while i < w:
i_end = min(i + wbin, w)
j = 0
@ -66,7 +68,8 @@ def clrImg(Img):
patch_merge_out_numpy = denoiser(patch, c, pss, model, model_est, opt)
merge_out[i:i_end, j:j_end, :] = patch_merge_out_numpy
j = j_end
gimp.progress_update(float(i+j)/float(w+h))
idx=idx+1
gimp.progress_update(float(idx)/float(t))
gimp.displays_flush()
i = i_end
@ -91,15 +94,15 @@ def createResultLayer(image, name, result):
gimp.displays_flush()
def deepdenoise(img, layer):
if torch.cuda.is_available():
def deepdenoise(img, layer,cFlag):
if torch.cuda.is_available() and not cFlag:
gimp.progress_init("(Using GPU) Denoising " + layer.name + "...")
else:
gimp.progress_init("(Using CPU) Denoising " + layer.name + "...")
imgmat = channelData(layer)
if imgmat.shape[2] == 4: # get rid of alpha channel
imgmat = imgmat[:,:,0:3]
cpy = clrImg(imgmat)
cpy = clrImg(imgmat,cFlag)
createResultLayer(img, 'new_output', cpy)
@ -114,6 +117,7 @@ register(
"*", # Alternately use RGB, RGB*, GRAY*, INDEXED etc.
[(PF_IMAGE, "image", "Input image", None),
(PF_DRAWABLE, "drawable", "Input drawable", None),
(PF_BOOL, "fcpu", "Force CPU", False)
],
[],
deepdenoise, menu="<Image>/Layer/GIML-ML")

13
gimp-plugins/deeplabv3.py
View File

@ -12,7 +12,7 @@ import torch
from torchvision import transforms, datasets
import numpy as np
def getSeg(input_image):
def getSeg(input_image,f):
model = torch.load(baseLoc+'weights/deeplabv3/deeplabv3+model.pt')
model.eval()
preprocess = transforms.Compose([
@ -23,7 +23,7 @@ def getSeg(input_image):
input_image = Image.fromarray(input_image)
input_tensor = preprocess(input_image)
input_batch = input_tensor.unsqueeze(0) # create a mini-batch as expected by the model
if torch.cuda.is_available():
if torch.cuda.is_available() and not f:
input_batch = input_batch.to('cuda')
model.to('cuda')
@ -61,8 +61,8 @@ def createResultLayer(image,name,result):
image.add_layer(rl,0)
gimp.displays_flush()
def deeplabv3(img, layer) :
if torch.cuda.is_available():
def deeplabv3(img, layer,cFlag) :
if torch.cuda.is_available() and not cFlag:
gimp.progress_init("(Using GPU) Generating semantic segmentation map for " + layer.name + "...")
else:
gimp.progress_init("(Using CPU) Generating semantic segmentation map for " + layer.name + "...")
@ -70,7 +70,7 @@ def deeplabv3(img, layer) :
imgmat = channelData(layer)
if imgmat.shape[2] == 4: # get rid of alpha channel
imgmat = imgmat[:,:,0:3]
cpy=getSeg(imgmat)
cpy=getSeg(imgmat,cFlag)
createResultLayer(img,'new_output',cpy)
@ -84,7 +84,8 @@ register(
"deeplabv3...",
"*", # Alternately use RGB, RGB*, GRAY*, INDEXED etc.
[ (PF_IMAGE, "image", "Input image", None),
(PF_DRAWABLE, "drawable", "Input drawable", None)
(PF_DRAWABLE, "drawable", "Input drawable", None),
(PF_BOOL, "fcpu", "Force CPU", False)
],
[],
deeplabv3, menu="<Image>/Layer/GIML-ML")

13
gimp-plugins/deepmatting.py
View File

@ -34,7 +34,7 @@ def createResultLayer(image,name,result):
image.add_layer(rl,0)
gimp.displays_flush()
def getnewalpha(image,mask):
def getnewalpha(image,mask,cFlag):
if image.shape[2] == 4: # get rid of alpha channel
image = image[:,:,0:3]
if mask.shape[2] == 4: # get rid of alpha channel
@ -44,7 +44,7 @@ def getnewalpha(image,mask):
trimap = mask[:, :, 0]
cudaFlag = False
if torch.cuda.is_available():
if torch.cuda.is_available() and not cFlag:
cudaFlag = True
args = Namespace(crop_or_resize='whole', cuda=cudaFlag, max_size=1600, resume=baseLoc+'weights/deepmatting/stage1_sad_57.1.pth', stage=1)
@ -75,8 +75,8 @@ def getnewalpha(image,mask):
return pred_mattes
def deepmatting(imggimp, curlayer,layeri,layerm) :
if torch.cuda.is_available():
def deepmatting(imggimp, curlayer,layeri,layerm,cFlag) :
if torch.cuda.is_available() and not cFlag:
gimp.progress_init("(Using GPU) Running deep-matting for " + layeri.name + "...")
else:
gimp.progress_init("(Using CPU) Running deep-matting for " + layeri.name + "...")
@ -84,7 +84,7 @@ def deepmatting(imggimp, curlayer,layeri,layerm) :
img = channelData(layeri)
mask = channelData(layerm)
cpy=getnewalpha(img,mask)
cpy=getnewalpha(img,mask,cFlag)
createResultLayer(imggimp,'new_output',cpy)
@ -101,7 +101,8 @@ register(
[ (PF_IMAGE, "image", "Input image", None),
(PF_DRAWABLE, "drawable", "Input drawable", None),
(PF_LAYER, "drawinglayer", "Original Image:", None),
(PF_LAYER, "drawinglayer", "Trimap Mask:", None)
(PF_LAYER, "drawinglayer", "Trimap Mask:", None),
(PF_BOOL, "fcpu", "Force CPU", False)
],
[],
deepmatting, menu="<Image>/Layer/GIML-ML")

24
gimp-plugins/facegen.py
View File

@ -56,7 +56,7 @@ def getOptions():
'engine': None,
'export_onnx': None,
'fineSize': 512,
'gpu_ids': [0],
'gpu_ids': [],
'how_many': 1000,
'input_nc': 3,
'isTrain': False,
@ -105,16 +105,19 @@ def createResultLayer(image,name,result):
image.add_layer(rl,0)
gimp.displays_flush()
def getnewface(img,mask,mask_m):
def getnewface(img,mask,mask_m,cFlag):
h,w,d = img.shape
img = Image.fromarray(img)
lmask = labelMask(mask)
lmask_m = labelMask(mask_m)
os.environ["CUDA_VISIBLE_DEVICES"] = str(0)
# os.environ["CUDA_VISIBLE_DEVICES"] = str(0)
opt = getOptions()
if torch.cuda.is_available() and not cFlag:
opt.gpu_ids=[0]
model = create_model(opt)
params = get_params(opt, (512,512))
@ -124,11 +127,11 @@ def getnewface(img,mask,mask_m):
mask_m = transform_mask(Image.fromarray(np.uint8(lmask_m)))
img = transform_image(img)
generated = model.inference(torch.FloatTensor([mask_m.numpy()]), torch.FloatTensor([mask.numpy()]), torch.FloatTensor([img.numpy()]))
generated = model.inference(torch.FloatTensor([mask_m.numpy()]), torch.FloatTensor([mask.numpy()]), torch.FloatTensor([img.numpy()]), cFlag)
result = generated.permute(0, 2, 3, 1)
if torch.cuda.is_available():
result = result.cpu().numpy()
result = result.detach().cpu().numpy()
else:
result = result.detach().numpy()
@ -141,8 +144,8 @@ def getnewface(img,mask,mask_m):
return result
def facegen(imggimp, curlayer,layeri,layerm,layermm) :
if torch.cuda.is_available():
def facegen(imggimp, curlayer,layeri,layerm,layermm,cFlag):
if torch.cuda.is_available() and not cFlag:
gimp.progress_init("(Using GPU) Running face gen for " + layeri.name + "...")
else:
gimp.progress_init("(Using CPU) Running face gen for " + layeri.name + "...")
@ -151,7 +154,7 @@ def facegen(imggimp, curlayer,layeri,layerm,layermm) :
mask = channelData(layerm)
mask_m = channelData(layermm)
cpy=getnewface(img,mask,mask_m)
cpy=getnewface(img,mask,mask_m,cFlag)
createResultLayer(imggimp,'new_output',cpy)
@ -168,8 +171,9 @@ register(
[ (PF_IMAGE, "image", "Input image", None),
(PF_DRAWABLE, "drawable", "Input drawable", None),
(PF_LAYER, "drawinglayer", "Original Image:", None),
(PF_LAYER, "drawinglayer", "Original Mask:", None),
(PF_LAYER, "drawinglayer", "Modified Mask:", None),
(PF_LAYER, "drawinglayer2", "Original Mask:", None),
(PF_LAYER, "drawinglayer3", "Modified Mask:", None),
(PF_BOOL, "fcpu", "Force CPU", False),
],
[],
facegen, menu="<Image>/Layer/GIML-ML")

13
gimp-plugins/faceparse.py
View File

@ -48,13 +48,13 @@ def colorMask(mask):
x=x+getlabelmat(mask,idx)
return np.uint8(x)
def getface(input_image):
def getface(input_image,cFlag):
save_pth = baseLoc+'weights/faceparse/79999_iter.pth'
input_image = Image.fromarray(input_image)
n_classes = 19
net = BiSeNet(n_classes=n_classes)
if torch.cuda.is_available():
if torch.cuda.is_available() and not cFlag:
net.cuda()
net.load_state_dict(torch.load(save_pth))
else:
@ -74,7 +74,7 @@ def getface(input_image):
img = input_image.resize((512, 512), Image.BILINEAR)
img = to_tensor(img)
img = torch.unsqueeze(img, 0)
if torch.cuda.is_available():
if torch.cuda.is_available() and not cFlag:
img = img.cuda()
out = net(img)[0]
if torch.cuda.is_available():
@ -137,8 +137,8 @@ def createResultLayer(image,name,result):
image.add_layer(rl,0)
gimp.displays_flush()
def faceparse(img, layer) :
if torch.cuda.is_available():
def faceparse(img, layer,cFlag) :
if torch.cuda.is_available() and not cFlag:
gimp.progress_init("(Using GPU) Running face parse for " + layer.name + "...")
else:
gimp.progress_init("(Using CPU) Running face parse for " + layer.name + "...")
@ -146,7 +146,7 @@ def faceparse(img, layer) :
imgmat = channelData(layer)
if imgmat.shape[2] == 4: # get rid of alpha channel
imgmat = imgmat[:,:,0:3]
cpy=getface(imgmat)
cpy=getface(imgmat,cFlag)
cpy = colorMask(cpy)
createResultLayer(img,'new_output',cpy)
@ -164,6 +164,7 @@ register(
"*", # Alternately use RGB, RGB*, GRAY*, INDEXED etc.
[ (PF_IMAGE, "image", "Input image", None),
(PF_DRAWABLE, "drawable", "Input drawable", None),
(PF_BOOL, "fcpu", "Force CPU", False)
],
[],
faceparse, menu="<Image>/Layer/GIML-ML")

4
gimp-plugins/ideepcolor/data/colorize_image.py Normal file → Executable file
View File

@ -250,7 +250,7 @@ class ColorizeImageTorch(ColorizeImageBase):
self.__patch_instance_norm_state_dict(state_dict, getattr(module, key), keys, i + 1)
# ***** Call forward *****
def net_forward(self, input_ab, input_mask):
def net_forward(self, input_ab, input_mask, f):
# INPUTS
# ab 2xXxX input color patches (non-normalized)
# mask 1xXxX input mask, indicating which points have been provided
@ -264,7 +264,7 @@ class ColorizeImageTorch(ColorizeImageBase):
# return prediction
# self.net.blobs['data_l_ab_mask'].data[...] = net_input_prepped
# embed()
output_ab = self.net.forward(self.img_l_mc, self.input_ab_mc, self.input_mask_mult, self.mask_cent)[0, :, :, :].cpu().data.numpy()
output_ab = self.net.forward(self.img_l_mc, self.input_ab_mc, self.input_mask_mult, self.mask_cent,f)[0, :, :, :].cpu().data.numpy()
self.output_rgb = lab2rgb_transpose(self.img_l, output_ab)
# self.output_rgb = lab2rgb_transpose(self.img_l, self.net.blobs[self.pred_ab_layer].data[0, :, :, :])

12
gimp-plugins/ideepcolor/models/pytorch/model.py Normal file → Executable file
View File

@ -131,7 +131,7 @@ class SIGGRAPHGenerator(nn.Module):
self.upsample4 = nn.Sequential(*[nn.Upsample(scale_factor=4, mode='nearest'), ])
self.softmax = nn.Sequential(*[nn.Softmax(dim=1), ])
def forward(self, input_A, input_B, mask_B, maskcent=0):
def forward(self, input_A, input_B, mask_B, maskcent=0,f=False):
# input_A \in [-50,+50]
# input_B \in [-110, +110]
# mask_B \in [0, +1.0]
@ -139,12 +139,14 @@ class SIGGRAPHGenerator(nn.Module):
input_A = torch.Tensor(input_A)[None, :, :, :]
input_B = torch.Tensor(input_B)[None, :, :, :]
mask_B = torch.Tensor(mask_B)[None, :, :, :]
if torch.cuda.is_available() and not f:
input_A = input_A.cuda()
input_B = input_B.cuda()
mask_B = mask_B.cuda()
mask_B = mask_B - maskcent
# input_A = torch.Tensor(input_A).cuda()[None, :, :, :]
# input_B = torch.Tensor(input_B).cuda()[None, :, :, :]
# mask_B = torch.Tensor(mask_B).cuda()[None, :, :, :]
conv1_2 = self.model1(torch.cat((input_A / 100., input_B / 110., mask_B), dim=1))
conv2_2 = self.model2(conv1_2[:, :, ::2, ::2])
conv3_3 = self.model3(conv2_2[:, :, ::2, ::2])

19
gimp-plugins/monodepth.py
View File

@ -13,10 +13,11 @@ from monodepth_net import MonoDepthNet
import MiDaS_utils as MiDaS_utils
import numpy as np
import cv2
import torch
def getMonoDepth(input_image):
def getMonoDepth(input_image,cFlag):
image = input_image / 255.0
out = run_depth(image, baseLoc+'weights/MiDaS/model.pt', MonoDepthNet, MiDaS_utils, target_w=640)
out = run_depth(image, baseLoc+'weights/MiDaS/model.pt', MonoDepthNet, MiDaS_utils, target_w=640,f=cFlag)
out = np.repeat(out[:, :, np.newaxis], 3, axis=2)
d1,d2 = input_image.shape[:2]
out = cv2.resize(out,(d2,d1))
@ -34,17 +35,22 @@ def channelData(layer): # convert gimp image to numpy
def createResultLayer(image, name, result):
rlBytes = np.uint8(result).tobytes();
rl = gimp.Layer(image, name, image.width, image.height, image.active_layer.type, 100, NORMAL_MODE)
rl = gimp.Layer(image, name, image.width, image.height, 0, 100, NORMAL_MODE)
region = rl.get_pixel_rgn(0, 0, rl.width, rl.height, True)
region[:, :] = rlBytes
image.add_layer(rl, 0)
gimp.displays_flush()
def MonoDepth(img, layer):
gimp.progress_init("Generating disparity map for " + layer.name + "...")
def MonoDepth(img, layer,cFlag):
if torch.cuda.is_available() and not cFlag:
gimp.progress_init("(Using GPU) Generating disparity map for " + layer.name + "...")
else:
gimp.progress_init("(Using CPU) Generating disparity map for " + layer.name + "...")
imgmat = channelData(layer)
cpy = getMonoDepth(imgmat)
if imgmat.shape[2] == 4: # get rid of alpha channel
imgmat = imgmat[:,:,0:3]
cpy = getMonoDepth(imgmat,cFlag)
createResultLayer(img, 'new_output', cpy)
@ -59,6 +65,7 @@ register(
"*", # Alternately use RGB, RGB*, GRAY*, INDEXED etc.
[(PF_IMAGE, "image", "Input image", None),
(PF_DRAWABLE, "drawable", "Input drawable", None),
(PF_BOOL, "fcpu", "Force CPU", False)
],
[],
MonoDepth, menu="<Image>/Layer/GIML-ML")

13
gimp-plugins/super_resolution.py
View File

@ -28,8 +28,8 @@ def colorMask(mask):
return np.uint8(x)
def getnewimg(input_image,s):
opt=Namespace(cuda=torch.cuda.is_available(),
def getnewimg(input_image,s,cFlag):
opt=Namespace(cuda=torch.cuda.is_available() and not cFlag,
model=baseLoc+'weights/super_resolution/model_srresnet.pth',
dataset='Set5',scale=s,gpus=0)
@ -88,8 +88,8 @@ def createResultLayer(name,layer_np):
gimp.displays_flush()
def super_resolution(img, layer,scale) :
if torch.cuda.is_available():
def super_resolution(img, layer,scale,cFlag) :
if torch.cuda.is_available() and not cFlag:
gimp.progress_init("(Using GPU) Running super-resolution for " + layer.name + "...")
else:
gimp.progress_init("(Using CPU) Running super-resolution for " + layer.name + "...")
@ -97,7 +97,7 @@ def super_resolution(img, layer,scale) :
imgmat = channelData(layer)
if imgmat.shape[2] == 4: # get rid of alpha channel
imgmat = imgmat[:,:,0:3]
cpy = getnewimg(imgmat,scale)
cpy = getnewimg(imgmat,scale,cFlag)
cpy = cv2.resize(cpy, (0,0), fx=scale/4, fy=scale/4)
createResultLayer(layer.name+'_upscaled',cpy)
@ -113,7 +113,8 @@ register(
"*", # Alternately use RGB, RGB*, GRAY*, INDEXED etc.
[ (PF_IMAGE, "image", "Input image", None),
(PF_DRAWABLE, "drawable", "Input drawable", None),
(PF_SLIDER, "Scale", "Scale", 4, (1.1, 4, 0.5))
(PF_SLIDER, "Scale", "Scale", 4, (1.1, 4, 0.5)),
(PF_BOOL, "fcpu", "Force CPU", False)
],
[],
super_resolution, menu="<Image>/Layer/GIML-ML")