Print

Please login or register.
1 Hour 1 Day 1 Week 1 Month Forever
Login with username, password and session length

[itisnotlogical]

I've been working on the same program for 6+ hours now. I've gotten to the point where I'm so tired that I don't even remember why half of the things are the way they are. The script looked like it was working with two inputs, but that just turned out to be a cruel illusion as it promtly shat itself and died when I tried with five inputs. As it is now, it won't even run and I'm too tired and demoralized to know for sure why.

Spoiler: texmerge.py (click to show/hide)

Code: [Select]

import sys, argparse
from texmerge_classes import output_image as output
from PIL import Image

args = sys.argv[1:]
parser = argparse.ArgumentParser(description="Combine multiple textures for use in 3D games or sprite sheets.")
parser.add_argument("input", nargs="+", help="Input image files")
parser.add_argument("-output", default='./output', help="Output file. Default is ./output")
parser.add_argument("-filetype", nargs=1, default='.png',
                    choices=['.png', '.jpg', '.jpeg'], help="Format of output file. Default is PNG")

args = parser.parse_args(args)

inputs = args.input
inputImages = []
outputDir = args.output
finalType = args.filetype

for i in range(0, len(inputs)):
    inputImages.append(Image.open(inputs[i]))

outputImage = output.OutputImage((Image.new('RGBA', size=(0, 0))), inputImages)

outputImage.merge_images()
outputImage.image.save(outputDir + finalType)
for region in outputImage.used_regions:
    print("Region used: " + str((region.x, region.y, region.width, region.height)))
for region in outputImage.empty_regions:
    print("Empty region: " + str((region.x, region.y, region.width, region.height)))

"""
Old way of doing it - make way for output_image!

outputImage = Image.new('RGBA', size=(1, 1))

for img in inputImages:
    print("Image size is " + str(img.size))
    old = outputImage.copy()

    if img.width > img.height:
        # if it's short, add it to the bottom
        yPosition = outputImage.height
        xPosition = 0

        if outputImage.width < img.width:
            newWidth = outputImage.width + (img.width - outputImage.width)
        else:
            newWidth = outputImage.width
        newSize = (newWidth, outputImage.height + img.height)
        outputImage = Image.new('RGBA', size=newSize)
        outputImage.paste(old, box=(0, 0))
        outputImage.paste(img, box=(xPosition, yPosition))
    else:
        # if it's tall, add it to the side
        yPosition = 0
        xPosition = outputImage.width

        if outputImage.height < img.height:
            newHeight = outputImage.height + (img.height - outputImage.height)
        else:
            newHeight = outputImage.height
        newSize = (outputImage.width + img.width, newHeight)
        outputImage = Image.new('RGBA', size=newSize)
        outputImage.paste(old, box=(0, 0))
        outputImage.paste(img, box=(xPosition, yPosition))

    print("Image size is " + str(img.size))
    xPosition = outputImage.width
    old = outputImage.copy()
    outputImage = Image.new('RGBA', size=(outputImage.width + img.width, outputImage.height + img.height))
    outputImage.paste(old, box=(0, 0, old.width, old.height))
    print("Current output size: " + str(outputImage.size))
    outputImage.paste(img, box=(xPosition, 0, xPosition+img.width, img.height))
    print("Pasted image to " + str((xPosition, 0, xPosition+img.width, img.height)))
"""

Spoiler: output_image.py inside module texmerge_classes (click to show/hide)

Code: [Select]

"""
output_image

Representation of the final output image and related methods.
"""

import sys
from PIL import Image
from math import ceil, floor


class Region:
    def __init__(self, x, y, width, height):
        self.x = x
        self.y = y
        self.width = width
        self.height = height

    def contains_point(self, x, y):
        if x in range(self.x, self.x + self.width) and y in range(self.y, self.y + self.height):
            #print("Point " + str((x, y)) + " is in " + str((self.x, self.y, self.width, self.height)))
            return True
        else:
            #print("Point " + str((x, y)) + " is not in " + str((self.x, self.y, self.width, self.height)))
            return False

    def area(self):
        area = ((self.width - self.x) * (self.height - self.y))
        return area


class OutputImage:
    def __init__(self, image=None, inputs=None, tiles_width=0, tiles_height=0):
        self.image = image
        self.inputs = inputs
        self.tiles_width = tiles_width
        self.tiles_height = tiles_height
        self.empty_regions = []
        self.used_regions = []
        self.cursor_position = [0, 0]
        self.empty = True

    def calculate_tile_dimensions(self):
        if isinstance(len(self.inputs)/2, float):
            self.tiles_width = ceil(len(self.inputs)/2)
            self.tiles_height = floor(len(self.inputs)/2)
        else:
            self.tiles_width, self.tiles_height = len(self.inputs)/2

    def merge_images(self):
        for image in self.inputs:
            self.add_image(image)

    def add_image(self, img):
        if self.empty:
            print("Adding first image")
            self.resize_output_image((img.width, img.height))
            self.image.paste(img, box=(0, 0))
            self.used_regions.append(Region(0, 0, img.width, img.height))
            self.empty = False
            return
        else:
            if len(self.empty_regions) > 0:
                for region in self.empty_regions:
                    if region.width >= img.width and region.height >= img.height:  # if there's an empty area big enough
                        print("Found empty area: Adding image")
                        self.image.paste(img, box=(region.x, region.y))
                        print("----- Pasted at " + str(region.x) + ", " + str(region.y) + " -----")
                        self.used_regions.append(Region(region.x, region.y,
                                                        region.x + img.width, region.y + img.height))
                        self.calculate_empty_regions()
                        break
                    elif region.height < img.height:
                        print("Cannot add image: No empty area tall enough, Expanding image")
                        self.resize_output_image((self.image.width, self.image.height + img.height))
                        self.calculate_empty_regions()
                        self.add_image(img)
                        break
                    else:  # if there's no empty area large enough, we need to expand
                        print("Cannot add image: No empty area wide enough, Expanding image")
                        self.resize_output_image((img.width, self.image.height))
                        self.calculate_empty_regions()
                        self.add_image(img)  # try again...
                        break
            else:  # if there's no empty area at all, we need to expand
                print("Cannot add image: No empty area at all, Expanding image height-first")
                self.resize_output_image((self.image.width, self.image.height + img.height))
                self.calculate_empty_regions()
                self.add_image(img)  # try again...

    def resize_output_image(self, new_size):
        old_image = self.image.copy()
        self.image = Image.new('RGBA', new_size)
        self.image.paste(old_image, box=(0, 0))
        print("Image size is now " + str((self.image.width, self.image.height)))

    def calculate_empty_regions(self):
        # n used regions results in n-1 unused regions
        self.empty_regions.clear()
        print("Calculating empty regions")
        for x in range(0, len(self.used_regions)):
            startpoint = self.find_first_empty_point()
            if startpoint[0] is not None:
                startx = startpoint[0]
                starty = startpoint[1]
                endpoint = self.find_last_empty_point()
                endx = endpoint[0]
                endy = endpoint[1]
                print("Found empty region " + str((startx, starty, endx, endy)))
                self.empty_regions.append(Region(startx, starty, endx, endy))
            else:
                print("calculate_empty_regions: Did not find empty point, returning")
                return

    def find_first_empty_point(self):
        print("Finding first empty point")
        for x in range(0, self.image.width):
            for y in range(0, self.image.height):
                #print("Checking point " + str((x, y)))
                region_checks = [True]
                for region in self.used_regions:
                    if region.contains_point(x, y):
                        region_checks.append(False)
                    else:
                        region_checks.append(True)
                #print("Region checks " + str(region_checks))
                #print(str(all(region_checks)))
                if all(region_checks) is True:
                    region_checks = [True]
                    for region in self.empty_regions:
                        if region.contains_point(x, y):
                            region_checks.append(False)
                            break
                        else:
                            region_checks.append(True)
                            break
                    if all(region_checks) is True:
                        print("Found last empty point " + str((x, y)))
                        return [x, y]
                    else:
                        return [None, None]
                else:
                    pass

    def find_last_empty_point(self):
        for x in range(self.image.width, 0, -1):
            for y in range(self.image.height, 0, -1):
                region_checks = [True]
                for region in self.used_regions:
                    if region.contains_point(x, y):
                        region_checks.append(False)
                    else:
                        region_checks.append(True)
                #print("Region checks " + str(region_checks))
                #print(str(all(region_checks)))
                if all(region_checks) is True:
                    region_checks = [True]
                    for region in self.empty_regions:
                        if region.contains_point(x, y):
                            region_checks.append(False)
                            break
                        else:
                            region_checks.append(True)
                            break
                    if all(region_checks) is True:
                        print("Found last empty point " + str((x, y)))
                        return [x, y]
                    else:
                        return [None, None]
                else:
                    pass


Don't ask me how it works, because I'm so tired that I don't even remember right now.

The most infuriating thing is, I'm 90% sure I would have had it if I'd went to bed less than an hour ago and worked on it after I'd gotten some sleep. I'm sure that a lot of easy-to-spot mistakes have added up into a huge unfixable mess, because I thought this was going to be so easy

[Avis-Mergulus]

Does anybody know a good Python library for working with XSD Schema files? I basically have a schema and a bunch of XML files, and I have to create another bunch of XML files that would conform to the schema, from the data in the first bunch. Previously, I just used BeautifulSoup, but it's become really obtuse.

I've tried PyXB and GenerateDS, but they don't want to work with Cyrillic tag names for some reason. Plus their documentation is arse, and I'm not really sure they're what I need.

[Spehss _]

So a C++ program I'm writing for a college assignment crashes at the end of the program. It brings up windows' "program has stopped responding blah blah blah" message. Not sure why. Never had this issue in a previous program. I've determined that the issue is somewhere in the last three lines of main(), involving an object, since if I comment those lines out the program runs fine and returns 0.

Spoiler (click to show/hide)

Code: [Select]

#include <iostream>

using namespace std;

class DataStorage
{
private:
string month;
int dayStart, dayEnd;
double arr[];
public:
DataStorage(int, string, int, int);
void fillArray(int, double);

string getMonth(){return month;}
int getStart(){return dayStart;}
int getEnd(){return dayEnd;}
double getArr(int i){return arr[i];}
};

DataStorage::DataStorage(int length, string m, int dS, int dE)
{
month=m;
dayStart=dS;
dayEnd=dE;
arr[length];
}

void DataStorage::fillArray(int slot, double data)
{
arr[slot]=data;
}

void getData(int length, DataStorage& object)
{
double input=0;
for(int i=0;i<length;i++)
{
cout<<"Enter snow depth for "<<object.getMonth()<<" "<<(object.getStart()+i)<<": ";
cin>>input;
object.fillArray(i, input);
}
}

void printOutput(int length, DataStorage& object)
{
cout<<"\nDisplaying report for "<<object.getMonth()<<" "
<<object.getStart()<<" - "<<object.getEnd()<<"\n"
<<"----------------------------------------\n"
<<"Date \t Base\n";
for(int i=0;i<length;i++)
{
cout<<object.getStart()+i<<"\t "<<object.getArr(i)<<"\n";
}
cout<<endl;
}

int main()
{
string uName="";
int uStart=0, uEnd=0;
const int LENGTH=7;
cout<<"Enter month of snowfall: ";
cin>>uName;
/* while(!nameCheck(uName))
{
cout<<"\nError. Must be a valid month."
<<"Enter month of snowfall: ";
cin>>uName;
}
*/
cout<<"Enter starting day: ";
cin>>uStart;
uEnd=uStart+(LENGTH-1);
//cout<<"Month: "<<uName<<" start: "<<uStart<<" end: "<<uEnd; //debug

//crashing bug must be somewhere between this line
DataStorage dataSet1(LENGTH, uName, uStart, uEnd);
getData(LENGTH, dataSet1);
//and this line

printOutput(LENGTH, dataSet1); //printOutput shouldn't have any effect on the crash bug since it was crashing before I even adding the printoutput function call.

return 0;
}


Anyone know what the problem might be? It doesn't seem to have any impact on how the program runs, but crashing looks bad and I wouldn't want to turn in a program that crashes at the end for grading.

[Mephisto]

<crashy code>

Not having looked at C++ seriously in several years, can you tell me what this does?

Code: [Select]

arr[length];

My assumption would be accessing memory that contains junk data.

[Reelya]

This line in the constructor arr[length]; isn't a valid way to size an array, it's just trying to access memory address "arr+length", which is invalid since arr hasn't been initialized yet. What you want here is:

arr = new double[length];

And then you need a destructor with a matching deallocation call:

DataStorage::~DataStorage()
{
    delete [] arr;
}

Actually, if you want to be extra smart, you put an if statement in the destructor:

DataStorage::~DataStorage()
{
    if(arr != 0)
    {
        delete [] arr;
    }
}

This avoids possible crashes in cases where the dynamic memory isn't actually allocated in the constructor, and there is an init function that does that instead. trying to delete a null pointer causes a crash.

[Spehss _]

snip

snip

I see. Fixed it. The programming class went over using pointers, new, and dynamic memory for stuff like arrays recently but I did not think of using it. Not in the habit of it.

Thanks for the in-depth answer, Reelya. Really cleared up what I did wrong.

[Gatleos]

So, I'm trying to get more practice maintaining SQL databases by making a database of personal info for myself. So far I have a few useful things, like people's birthdays and the dates I bought certain things. Anyone have any other ideas for things I could keep track of with a relational database?

[itisnotlogical]

dates that you added entries to the database, including the dates of those entries

Seriously though: recipes. People ALWAYS lose recipes. They forget what version of a recipe from what website they liked, and if they write it down then they lose the paper.

[Reelya]

Not knowing your personal details or interests it would be hard to know what to recommend. The point of relational databases is the relational part: i.e. just storing some tables of data isn't utilizing what makes relational databases work. To get better with relational databases you really need to do joins on multiple tables.

If you shared your basic database schema I could probably recommend some stuff to try. But I can kinda guess that this would help:

Spoiler (click to show/hide)

Make your birthday thing as complex as possible, rather than e.g. just the common-sense thing of having a "date of birth" field right in the person table.

- have a record for each person. i.e. person_id, name

- have an "events" table, with 4 fields per record: event_id, person_id, event_type_id, date

- have an "event_types" table, with event_type_id, event_name

- do joins so you can query any type of event e.g. "birthday"

So, now you could record an arbitrary number of different dates per person, split into an arbitrary number of searchable categories. Actually, to make this more logically consistent, you might want to turn the person table into an "entity" table, and "person_id" to "entity_id", then you can use the "events" table to cover dates for people, and dates for things. And while you're at it, add a "target_id" to the events, so you can record "date <me> bought <thing>" in the same table that you have "date <person> married <other_person>"

entity_table: entity_id, name, entity_type_id

entity_type_table: entity_type_id, name

events_table: event_id, subject_id, object_id, event_type_id, date

event_types_table: event_type_id, event_name

Now, the thing is even better and more general and can store a huge amount of different types of info.

Seriously though: recipes. People ALWAYS lose recipes. They forget what version of a recipe from what website they liked, and if they write it down then they lose the paper.

Maybe that's a personal thing. Also, by itself "recipes" is not an interesting thing to store in a relational database, unless you do something "relational" with them, such as make a recipe database that had links to all the ingredients, and a separate table of current stocks. Then you could write a procedure to select recipes that could be made with the minimal purchases.

[Telgin]

This avoids possible crashes in cases where the dynamic memory isn't actually allocated in the constructor, and there is an init function that does that instead. trying to delete a null pointer causes a crash.

It surprised me to learn a while back that you actually can delete NULL pointers safely.  I'd written an awful lot of code that checked for NULL before deleting prior to me reading up on it by chance.

Of course, you still need the check unless you initialize the pointer to NULL somewhere before the delete.  Calling delete on an uninitialized pointer is definitely going to cause crashes.

[Bumber]

So, I'm trying to get more practice maintaining SQL databases by making a database of personal info for myself. So far I have a few useful things, like people's birthdays and the dates I bought certain things. Anyone have any other ideas for things I could keep track of with a relational database?

Songs you like? Video games/movies/shows/books you have yet to play/watch/read?

I keep large text files of songs (mostly on youtube) I might like to listen to again. I've been meaning to put them into an RDB so I can sort by artist, prevent redundancy, etc., but haven't gotten around to it.

[Gatleos]

All good suggestions. Obviously the data doesn't all have to utilize RDB features specifically, but I am doing it partially to learn those features, so it helps.

[RoguelikeRazuka]

Hey, could someone confident in Python review my program (which is a hometask I have been given by the teacher in university where I'm studying) for encoding/decoding messages using Huffman code? I wonder how efficient, readable, correct etc it is? Sorry I really haven't a person to ask.

Here's the link: http://pastebin.com/2JaqFCn2

[MagmaMcFry]

Hey, could someone confident in Python review my program (which is a hometask I have been given by the teacher in university where I'm studying) for encoding/decoding messages using Huffman code? I wonder how efficient, readable, correct etc it is? Sorry I really haven't a person to ask.

Here's the link: http://pastebin.com/2JaqFCn2

It seems correct, but the runtime efficiency has a lot of room for improvement:

Let n be the number of symbols in your alphabet.

First off, you're using a gnomesort on the queue every iteration of the tree building loop, and the gnomesort takes O(n^2) in the first iteration and O(n) in subsequent iterations. You can improve this by sorting the queue with a faster algorithm first once (making it O(n log n)), and then in subsequent iterations starting the gnomesort right at the last element (i = len(queue)) instead of attempting to sort the (already sorted) beginning of the queue every time. If you want to be really smart about it, you could just make the queue a heapq, that's exactly the data structure you need for best runtime.

Next, you're building the code table symbol by symbol by using expensive "in" calls in a potentially unbalanced tree, making the algorithm O(n^2) best case, O(n^3) worst case. This could be improved by a factor of n/log n by starting out with a dict((sym, "") for sym in alphabet), then iterating over the tree breadth-first instead of iterating over the alphabet, and appending the code symbol of each traversed node to the code of each symbol in that node's symbol list.

Finally and most importantly, your decoding algorithm doesn't actually make any use of the shiny new decision tree you just built! If you use the decision tree, you can speed things up from O(n log˛ n) to O(log n) best case, and from O(n^3) to O(n) worst case!

Here's how to use the decision tree: Start at the root of the tree. Follow the branch indicated by the first bit of the coded message. Follow the branch indicated by the second bit of the coded message. Repeat until you're at a leaf node. There's your first character. Now go back to the root of the tree. Repeat until you're out of coded message.

Also there's a typo: "Dencoding".

[RoguelikeRazuka]

Hey, could someone confident in Python review my program (which is a hometask I have been given by the teacher in university where I'm studying) for encoding/decoding messages using Huffman code? I wonder how efficient, readable, correct etc it is? Sorry I really haven't a person to ask.

Here's the link: http://pastebin.com/2JaqFCn2

It seems correct, but the runtime efficiency has a lot of room for improvement:

Let n be the number of symbols in your alphabet.

First off, you're using a gnomesort on the queue every iteration of the tree building loop, and the gnomesort takes O(n^2) in the first iteration and O(n) in subsequent iterations. You can improve this by sorting the queue with a faster algorithm first once (making it O(n log n)), and then in subsequent iterations starting the gnomesort right at the last element (i = len(queue)) instead of attempting to sort the (already sorted) beginning of the queue every time. If you want to be really smart about it, you could just make the queue a heapq, that's exactly the data structure you need for best runtime.

Next, you're building the code table symbol by symbol by using expensive "in" calls in a potentially unbalanced tree, making the algorithm O(n^2) best case, O(n^3) worst case. This could be improved by a factor of n/log n by starting out with a dict((sym, "") for sym in alphabet), then iterating over the tree breadth-first instead of iterating over the alphabet, and appending the code symbol of each traversed node to the code of each symbol in that node's symbol list.

Finally and most importantly, your decoding algorithm doesn't actually make any use of the shiny new decision tree you just built! If you use the decision tree, you can speed things up from O(n log˛ n) to O(log n) best case, and from O(n^3) to O(n) worst case!

Here's how to use the decision tree: Start at the root of the tree. Follow the branch indicated by the first bit of the coded message. Follow the branch indicated by the second bit of the coded message. Repeat until you're at a leaf node. There's your first character. Now go back to the root of the tree. Repeat until you're out of coded message.

Also there's a typo: "Dencoding".

Thank you for the reply, it was really helpful! Where can I read about the computational complexity of various data structures and functions implemented in python? And how do you determine how (and to what degree) it's possible to improve performance of a given operation?