def __init__(self, solve_url, use_proxies=True, headless=False):
options = Options()
options.headless = headless
profile = webdriver.FirefoxProfile()
if use_proxies:
proxy = load_proxy()
profile.set_preference("network.proxy.type", 1)
profile.set_preference("network.proxy.http", proxy["ip"])
profile.set_preference("network.proxy.http_port", proxy["port"])
if "username" in proxy:
credentials = b64encode(
f'{proxy["username"]}:{proxy["password"]}'.encode(
"ascii")).decode()
profile.set_preference("extensions.closeproxyauth.authtoken",
credentials)
profile.set_preference("dom.webdriver.enabled", False)
profile.set_preference("useAutomationExtension", False)
profile.update_preferences()
try:
self.driver = webdriver.Firefox(firefox_profile=profile,
options=options)
except WebDriverException:
options.headless = True
self.driver = webdriver.Firefox(firefox_profile=profile,
options=options)
self.image_handler = ImageHandler()
self.solve_url = solve_url
self.recaptcha_task = RecaptchaTask()
def posts_main(posts_list):
res_list = []
for post in posts_list:
# Send to Text Module
text_app = TextHandler().main(post.title, post.text)
# Send to Image Module
image_app = ImageHandler().main(post.images)
res_list.append((post.id, text_app, image_app))
return res_list
def command_get_white_black_img(update: Update, context: CallbackContext):
"""This function is processing image by the black_white filter"""
img = ImageHandler()
img.get_black_white_img()
reply_markup = ReplyKeyboardRemove() # Remove keyboard
bot.send_message(chat_id=update.message.chat_id,
text="Upload new image",
reply_markup=reply_markup)
def __init__(self):
self.classnames = [
"background", "person", "crutches", "walking_frame", "wheelchair",
"push_wheelchair"
]
#read rosparams
config_file = rospy.get_param('~model_config', "")
self.fixed_frame = rospy.get_param('~fixed_frame', 'odom')
self.tracking = rospy.get_param('~tracking', True)
self.filter_detections = rospy.get_param('~filter_inside_boxes', True)
self.inside_box_ratio = rospy.get_param('~inside_box_ratio', 0.8)
camera_topic = rospy.get_param('~camera_topic',
'/kinect2/qhd/image_color_rect')
camera_info_topic = rospy.get_param('~camera_info_topic',
'/kinect2/qhd/camera_info')
#initialize subscribers
rospy.Subscriber(camera_topic,
Image,
self.image_callback,
queue_size=1)
rospy.Subscriber(camera_info_topic,
CameraInfo,
self.cam_info_callback,
queue_size=1)
#detection model and tracker
self.setup_model_and_tracker(config_file)
#image queues
self.last_received_image = None #set from image topic
self.last_processed_image = None #set from image topic
self.new_image = False
self.cam_calib = None #set from camera info
self.camera_frame = None #set from camera info
#helpers
Server(TrackingParamsConfig, self.reconfigure_callback)
bridge = CvBridge()
self.viz_helper = Visualizer(len(self.classnames))
self.publisher = Publisher(self.classnames, bridge)
self.image_handler = ImageHandler(bridge, cfg.TEST.MAX_SIZE,
cfg.TEST.SCALE)
self.tfl = tf.TransformListener()
def __init__(self, options, gpu_ids=[]):
self.options = options
self.model = NetworkBench(n_networks=options.n_networks,
n_input_channels=options.input_nc,
n_output_channels=options.output_nc,
n_blocks=options.n_blocks,
initial_filters=options.initial_filters,
dropout_value=options.dropout_value,
lr=options.lr,
decay=options.decay,
decay_epochs=options.decay_epochs,
batch_size=options.batch_size,
image_width=options.image_width,
image_height=options.image_height,
load_network=options.load_network,
load_epoch=options.load_epoch,
model_path=os.path.join(
options.model_path, options.name),
name=options.name,
gpu_ids=gpu_ids,
dont_care=options.dont_care,
gan=options.gan,
pool_size=options.pool_size,
lambda_gan=options.lambda_gan,
n_blocks_discr=options.n_blocks_discr)
self.model.cuda()
self.dont_care = options.dont_care
self.gan = options.gan
if self.gan:
self.discriminator_datasets = DataLoaderDiscriminator(
options).load_data()
self.data_sets = CorrespondenceDataLoaderDontCare(options).load_data()
self.image_handler = ImageHandler()
self.loss_dir = self.options.output_path + "/" + self.options.name + "/Train"
copyfile(
os.path.relpath('seg_config.yaml'),
os.path.join(self.options.model_path, self.options.name,
'seg_config.yaml'))
self.writer = SummaryWriter(self.loss_dir)
def main():
app = QtWidgets.QApplication(sys.argv)
main_view = MainView(app)
controls = Controls()
main_view.subscribe_controls(controls)
metrics_engine = MetricsEngine()
metrics_engine.subscribe_view(main_view)
metrics_engine.load_metrics()
controls.subscribe_view(main_view)
image_handler = ImageHandler()
image_handler.subscribe_view(main_view)
modifications_provider = ModificationsProvider()
modifications_provider.subscribe_image_handler(image_handler)
controls.subscribe_image_handler(image_handler)
controls.subscribe_modifications_provider(modifications_provider)
image_handler.subscribe_metrics_engine(metrics_engine)
main_view.show()
sys.exit(app.exec_())
def __init__(self, options, gpu_ids=[]):
self.options = options
self.model = NetworkBench(
n_networks=options.n_networks,
n_input_channels=options.input_nc,
n_output_channels=options.output_nc * options.n_labels,
n_blocks=options.n_blocks,
initial_filters=options.initial_filters,
dropout_value=options.dropout_value,
lr=options.lr,
decay=options.decay,
decay_epochs=options.decay_epochs,
batch_size=options.batch_size,
image_width=options.image_width,
image_height=options.image_height,
load_network=options.load_network,
load_epoch=options.load_epoch,
model_path=os.path.join(options.model_path, options.name),
name=options.name,
gpu_ids=gpu_ids,
gan=options.gan,
pool_size=options.pool_size,
lambda_gan=options.lambda_gan,
n_blocks_discr=options.n_blocks_discr)
# FIXME: Save Graph to tensorboardX
self.model.cuda()
self.n_labels = options.n_labels
self.gan = options.gan
self.data_sets = CorrespondenceDataLoaderMultiLabel(
options).load_data()
self.image_handler = ImageHandler()
self.log_dir = self.options.output_path + "/" + self.options.name + "/Train"
copyfile(
os.path.relpath('seg_config.yaml'),
os.path.join(self.options.model_path, self.options.name,
'seg_config.yaml'))
self.writer = Summarywriter(self.log_dir)
def _start_threads(self):
self.__image_handler = ImageHandler(self.__gui)
self.__video_handler = VideoHandler(self.__gui)
self.__camera_handler = CameraHandler(self.__gui)
self.__display_handler = self.__image_handler
"""
This module is reserved for arbitrary helper functions
"""
import os
from downloader import download
from image_handler import ImageHandler
images = ImageHandler('%s/SaturnServer/images/' % os.path.expanduser('~'))
description='Command to reduce image size and lossless compression')
parser.add_argument('inputDir', help='Input directory to be monitored')
parser.add_argument(
'outputDir',
help='Output directory where transformed images will be saved')
parser.add_argument(
'-r',
'--ratio',
type=float,
default=1.0,
help='Reduce size ratio, from 0.0 to 1.0, default: 1.0')
args = parser.parse_args()
# Image handler setup
logger.info(
'Process started. Monitoring directory: {inputDir}. Output directory: {outputDir}'
.format(inputDir=args.inputDir, outputDir=args.outputDir))
observer: Observer = Observer()
event_handler: ImageHandler = ImageHandler(size_ratio=args.ratio,
dest_path=args.outputDir)
observer.schedule(event_handler, args.inputDir)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join
# encoding: cp1252
import pygame, os
import pyautogui
from image_handler import ImageHandler
from Tkinter import Tk
from PIL import Image
from options_gui import OptionsGUI
pygame.init()
if __name__ == "__main__":
im_handle = ImageHandler()
pyautogui.screenshot('foo.png')
input_loc = 'foo.png'
output_loc = 'out.png'
screen, px = im_handle.setup(input_loc)
left, upper, right, lower = im_handle.mainLoop(screen, px)
# ensure output rect always has positive width, height
if right < left:
left, right = right, left
if lower < upper:
lower, upper = upper, lower
im = Image.open(input_loc)
im = im.crop((left, upper, right, lower))
pygame.display.quit()
im.save(output_loc)
os.remove(input_loc)
# File options
root = Tk()
from image_handler import ImageHandler
import cv2
import os
import time
if __name__ == '__main__':
image_index = len(os.listdir(os.path.join("cache")))
while True:
for _ in range(10):
image_handler = ImageHandler()
if image_handler.is_legal():
print("legal")
image_list = image_handler.generate_uniform_image()
image = image_handler.get_gray_static_image()
cv2.imwrite(
os.path.join("origin",
"{}.png".format(str(image_index).zfill(5))),
image)
image_index += 1
if image_handler.get_suffix() == "png":
dest_dir = "png"
else:
dest_dir = "gif"
for image in image_list:
cv2.imwrite(
os.path.join(
def __init__(self):
self.classnames = [
"background", "person", "crutches", "walking_frame", "wheelchair",
"push_wheelchair"
]
detectron_ops_lib = net_helper.get_detectron_ops_lib()
dyndep.InitOpsLibrary(detectron_ops_lib)
model_path = rospy.get_param("~model_path")
self.fixed_frame = rospy.get_param('~fixed_frame', 'odom')
self.tracking = rospy.get_param('~tracking', True)
self.filter_detections = rospy.get_param('~filter_inside_boxes', True)
self.inside_box_ratio = rospy.get_param('~inside_box_ratio', 0.8)
camera_topic = rospy.get_param('~camera_topic',
'/camera/color/image_raw')
camera_info_topic = rospy.get_param('~camera_info_topic',
'/camera/color/camera_info')
self.net = caffe2_pb2.NetDef()
with open(os.path.join(model_path, "model.pb"), "rb") as f:
self.net.ParseFromString(f.read())
self.init_net = caffe2_pb2.NetDef()
with open(os.path.join(model_path, "model_init.pb"), "rb") as f:
self.init_net.ParseFromString(f.read())
workspace.ResetWorkspace()
workspace.RunNetOnce(self.init_net)
for op in self.net.op:
for blob_in in op.input:
if not workspace.HasBlob(blob_in):
workspace.CreateBlob(blob_in)
workspace.CreateNet(self.net)
# initialize subscribers
rospy.Subscriber(camera_topic,
Image,
self.image_callback,
queue_size=1)
rospy.Subscriber(camera_info_topic,
CameraInfo,
self.cam_info_callback,
queue_size=1)
# image queues
self.last_received_image = None # set from image topic
self.last_processed_image = None # set from image topic
self.new_image = False
self.cam_calib = None # set from camera info
self.camera_frame = None # set from camera info
bridge = CvBridge()
self.publisher = Publisher(self.classnames, bridge)
observation_model = np.loadtxt(os.path.join(model_path,
"observation_model.txt"),
delimiter=',')
ekf_sensor_noise = np.loadtxt(os.path.join(model_path, "meas_cov.txt"),
delimiter=',')
self.tracker = Tracker(ekf_sensor_noise,
observation_model,
use_hmm=True)
self.tfl = tf.TransformListener()
self.image_handler = ImageHandler(bridge, 540, 960)
Server(TrackingParamsConfig, self.reconfigure_callback)
thresholds = {}
with open(os.path.join(model_path, "AP_thresholds.txt")) as f:
for line in f:
(key, val) = line.split(',')
thresholds[key] = float(val)
self.cla_thresholds = thresholds
def run_style_transfer(image_size,
content_image_path,
style_image_path,
content_layers_weights,
style_layers_weights,
variation_weight,
n_steps,
shifting_activation_value,
device_name,
preserve_colors):
print('Transfer style to content image')
print('Number of iterations: %s' % n_steps)
print('Preserve colors: %s' % preserve_colors)
print('--------------------------------')
print('Content image path: %s' % content_image_path)
print('Style image path: %s' % style_image_path)
print('--------------------------------')
print('Content layers: %s' % content_layers_weights.keys())
print('Content weight: %s' % style_layers_weights.keys())
print('Style layers: %s' % content_layers_weights.values())
print('Style weight: %s' % style_layers_weights.values())
print('Variation weight: %s' % variation_weight)
print('--------------------------------')
print('Shifting activation value: %s' % shifting_activation_value)
print('--------------------------------\n\n')
device = torch.device("cuda" if (torch.cuda.is_available() and device_name == 'cuda') else "cpu")
image_handler = ImageHandler(image_size=image_size,
content_image_path=content_image_path,
style_image_path=style_image_path,
device=device,
preserve_colors=preserve_colors)
content_layer_names = list(content_layers_weights.keys())
style_layer_names = list(style_layers_weights.keys())
layer_names = content_layer_names + style_layer_names
last_layer = get_last_used_conv_layer(layer_names)
model = transfer_vgg19(last_layer, device)
print('--------------------------------')
print('Model:')
print(model)
print('--------------------------------')
content_features = model(image_handler.content_image, content_layer_names)
content_losses = {layer_name: ContentLoss(weight=weight)
for layer_name, weight in content_layers_weights.items()}
style_features = model(image_handler.style_image, style_layer_names)
style_losses = {layer_name: StyleLoss(weight=weight,
shifting_activation_value=shifting_activation_value)
for layer_name, weight in style_layers_weights.items()}
variation_loss = VariationLoss(weight=variation_weight)
combination_image = image_handler.content_image.clone()
optimizer = optim.LBFGS([combination_image.requires_grad_()])
run = [0]
while run[0] <= n_steps:
def closure():
# correct the values of updated input image
combination_image.data.clamp_(0, 1)
optimizer.zero_grad()
out = model(combination_image, layer_names)
variation_score = variation_loss(combination_image)
content_score = torch.sum(torch.stack([loss(out[layer_name], content_features[layer_name].detach())
for layer_name, loss in content_losses.items()]))
style_score = torch.sum(torch.stack([loss(out[layer_name], style_features[layer_name].detach())
for layer_name, loss in style_losses.items()]))
loss = style_score + content_score + variation_score
loss.backward()
run[0] += 1
if run[0] % 50 == 0:
print("run {}:".format(run))
print('Style Loss : {:4f} Content Loss: {:4f} Variation Loss: {:4f}'.format(
style_score.item(), content_score.item(), variation_score.item()))
return loss
optimizer.step(closure)
# a last correction...
combination_image.data.clamp_(0, 1)
plt.figure()
image_handler.imshow(combination_image, title='Output Image')
plt.show()
return image_handler.image_unloader(combination_image)
