I want to use these logo edge coordinates Edge Map for the Logo:
Bounding Box: {'x': 887, 'y': 967, 'width': 38, 'height': 34}
Corner Points:
  - (np.int32(887), np.int32(967))
  - (np.int32(901), np.int32(997))
  - (np.int32(909), np.int32(999))
  - (np.int32(924), np.int32(967))
  - (np.int32(917), np.int32(967))
  - (np.int32(906), np.int32(989))
  - (np.int32(894), np.int32(967))
Do this effect 
Digital reassembly
Using this script as your base. 

import numpy as np
import cv2
from PIL import Image, ImageDraw, ImageFilter, ImageChops, ImageEnhance
import imageio
import os
from pathlib import Path
import math

class NeonAnimator:
    def __init__(self):
        # Base neon colors with increased vibrancy
        self.neon_colors = [
            (0, 255, 255),    # Cyan
            (255, 0, 255),    # Magenta
            (255, 128, 0),    # Orange
            (0, 255, 128)     # Turquoise
        ]
        
        # Enhanced pulse colors for energy waves
        self.pulse_colors = [
            (128, 255, 255),  # Bright Cyan
            (255, 128, 255),  # Bright Magenta
            (255, 192, 128),  # Bright Orange
            (128, 255, 192)   # Bright Turquoise
        ]
        
        # Core energy colors (near-white variations)
        self.core_colors = [
            (192, 255, 255),  # White-Cyan
            (255, 192, 255),  # White-Magenta
            (255, 224, 192),  # White-Orange
            (192, 255, 224)   # White-Turquoise
        ]
        
        self.frames = []
        self.size = (1024, 1024)
        
        # Animation parameters
        self.frames_per_color = 30
        self.pulse_frequency = 15
        self.pulse_width = 40
        self.wave_speed = 3
        self.energy_buildup = 0.0
        
    def create_glow(self, img, amount=2, color=(255, 255, 255), intensity=1.0):
        img_pil = Image.fromarray(img)
        if len(color) == 3:
            color = (*color, int(255 * intensity))
        glow = img_pil.copy()
        glow = glow.filter(ImageFilter.GaussianBlur(amount))
        glow = ImageEnhance.Brightness(glow).enhance(1.5 * intensity)
        colored_glow = Image.new('RGBA', glow.size, color)
        glow = ImageChops.multiply(glow, colored_glow)
        return np.array(glow)

    def create_pulse_wave(self, points, progress, color, intensity=1.0):
        wave = Image.new('RGBA', self.size, (0, 0, 0, 0))
        draw = ImageDraw.Draw(wave)
        
        n_points = len(points)
        wave_center = int(progress * n_points)
        
        for i in range(n_points):
            dist = min((i - wave_center) % n_points, (wave_center - i) % n_points)
            if dist < self.pulse_width:
                pulse_intensity = intensity * (1 - (dist / self.pulse_width) ** 2)
                x, y = points[i]
                alpha = int(200 * pulse_intensity)
                draw.ellipse([x-3, y-3, x+3, y+3], 
                           fill=(*color, alpha))
        
        return wave

    def generate_edge_animation(self, image_path):
        # Load and process image
        original = Image.open(image_path).convert('RGBA')
        original = original.resize(self.size)
        original_np = np.array(original)
        
        # Edge detection
        gray = cv2.cvtColor(original_np[:,:,:3], cv2.COLOR_RGB2GRAY)
        edges = cv2.Canny(gray, 50, 150)
        edge_points = np.where(edges > 0)
        points = list(zip(edge_points[1], edge_points[0]))
        
        if not points:
            raise ValueError("No edges detected in the image")
        
        total_frames = self.frames_per_color * len(self.neon_colors)
        
        for frame in range(total_frames):
            # Color calculations
            color_idx = frame // self.frames_per_color
            next_color_idx = (color_idx + 1) % len(self.neon_colors)
            blend_factor = (frame % self.frames_per_color) / self.frames_per_color
            
            # Color blending for all color types
            base_color = tuple(int(c1 * (1 - blend_factor) + c2 * blend_factor)
                             for c1, c2 in zip(self.neon_colors[color_idx], 
                                             self.neon_colors[next_color_idx]))
            
            pulse_color = tuple(int(c1 * (1 - blend_factor) + c2 * blend_factor)
                              for c1, c2 in zip(self.pulse_colors[color_idx],
                                              self.pulse_colors[next_color_idx]))
            
            core_color = tuple(int(c1 * (1 - blend_factor) + c2 * blend_factor)
                             for c1, c2 in zip(self.core_colors[color_idx],
                                             self.core_colors[next_color_idx]))
            
            # Create base neon layer
            base_layer = Image.new('RGBA', self.size, (0, 0, 0, 0))
            draw = ImageDraw.Draw(base_layer)
            
            # Energy buildup calculation
            energy_phase = (frame % self.pulse_frequency) / self.pulse_frequency
            energy_intensity = 1.0 + 0.5 * math.sin(energy_phase * 2 * math.pi)
            
            # Draw base edges with varying intensity
            for x, y in points:
                draw.ellipse([x-2, y-2, x+2, y+2], 
                           fill=(*base_color, int(180 * energy_intensity)))
            
            # Create pulse waves
            wave_progress = (frame * self.wave_speed) / len(points)
            pulse_wave = self.create_pulse_wave(points, wave_progress, pulse_color, energy_intensity)
            
            # Convert layers to numpy for processing
            base_array = np.array(base_layer)
            wave_array = np.array(pulse_wave)
            
            # Create multiple glow layers with different intensities
            glow1 = self.create_glow(base_array, 3, core_color, energy_intensity * 1.2)
            glow2 = self.create_glow(base_array, 6, pulse_color, energy_intensity * 0.8)
            glow3 = self.create_glow(wave_array, 4, core_color, energy_intensity)
            
            # Combine all effects
            final_image = Image.new('RGBA', self.size, (0, 0, 0, 0))
            final_image = Image.alpha_composite(final_image, Image.fromarray(glow2))
            final_image = Image.alpha_composite(final_image, Image.fromarray(glow1))
            final_image = Image.alpha_composite(final_image, base_layer)
            final_image = Image.alpha_composite(final_image, pulse_wave)
            final_image = Image.alpha_composite(final_image, Image.fromarray(glow3))
            
            self.frames.append(np.array(final_image))
    
    def save_gif(self, output_path):
        if not self.frames:
            raise ValueError("No frames generated yet. Run generate_edge_animation first.")
            
        os.makedirs(os.path.dirname(output_path), exist_ok=True)
        
        imageio.mimsave(
            output_path,
            self.frames,
            duration=40,  # Slightly slower for better pulse visibility
            loop=0
        )
        print(f"Animation saved to: {output_path}")

def main():
    try:
        animator = NeonAnimator()
        input_path = os.path.expanduser('~/auto/img/logo.png')
        output_path = os.path.expanduser('~/auto/output/new.gif')
        
        print(f"Processing image: {input_path}")
        animator.generate_edge_animation(input_path)
        animator.save_gif(output_path)
        print("Animation completed successfully!")
        
    except Exception as e:
        print(f"Error: {str(e)}")

if __name__ == "__main__":
    main()