def crea_richiesta_supporto(request):
    if request.method == 'POST':
        form = RichiestaSupportoForm(data=request.POST)
        if form.is_valid():
            pk = form.cleaned_data['id_richiesta']
            imei = form.cleaned_data['imei']
            playerId = form.cleaned_data['playerId']
            fo = form.cleaned_data['forza_ordine']
            richiestaMaster = Richiesta.objects.get(id=pk)
            subRichiesta = Richiesta(imei=imei,
                                     tipologia=richiestaMaster.tipologia,
                                     stato=Richiesta.CREATA,
                                     informazioni=richiestaMaster.informazioni,
                                     data=richiestaMaster.data,
                                     is_supporto=pk,
                                     linea_verde_richiesta=False,
                                     long=richiestaMaster.long,
                                     lat=richiestaMaster.lat,
                                     playerId=playerId,
                                     forza_ordine=fo)
            subRichiesta.save()
            allegati = Allegato.objects.filter(richiesta=richiestaMaster)
            for fl in allegati:
                tmp_file = io.BytesIO(fl.file.read())
                tmp_file = ContentFile(tmp_file.getvalue())
                tmp_file.name = get_file_name(fl.file.name)
                a = Allegato(file=tmp_file, richiesta=subRichiesta)
                a.save()
            response = push_to_nearest(subRichiesta.pk, subRichiesta.tipologia,
                                       subRichiesta.lat, subRichiesta.long,
                                       Richiesta.RICHIESTA_DA_FO_ALLEGATI)
            print(response)
            return HttpResponse(subRichiesta.serialize())
    return HttpResponseForbidden()
Beispiel #2
0
def draw_graph(rules, rules_to_show):
    if (len(rules) < rules_to_show):
        rules_to_show = len(rules)
    plt.gcf().clear()
    G1 = nx.DiGraph()
    color_map = []
    N = rules_to_show
    colors = np.random.rand(N)
    print(colors)
    strs = [
        'R0', 'R1', 'R2', 'R3', 'R4', 'R5', 'R6', 'R7', 'R8', 'R9', 'R10',
        'R11'
    ]

    for i in range(rules_to_show):
        G1.add_nodes_from(["R" + str(i)])

        for a in rules.iloc[i]['antecedents']:
            G1.add_nodes_from([a])
            G1.add_edge(a, "R" + str(i), color=colors[0], weight=2)

        for c in rules.iloc[i]['consequents']:
            G1.add_nodes_from([c])
            G1.add_edge("R" + str(i), c, color=colors[0], weight=2)

    for node in G1:
        found_a_string = False
        for item in strs:
            if node == item:
                found_a_string = True
        if found_a_string:
            color_map.append('yellow')
        else:
            color_map.append('green')

    edges = G1.edges()
    colors = [G1[u][v]['color'] for u, v in edges]
    weights = [G1[u][v]['weight'] for u, v in edges]

    pos = nx.spring_layout(G1, scale=1)
    nx.draw(G1,
            pos,
            edges=edges,
            node_color=color_map,
            edge_color=colors,
            width=weights,
            font_size=16,
            with_labels=False)

    for p in pos:  # raise text positions
        pos[p][1] += 0.07
    nx.draw_networkx_labels(G1, pos)
    plt.tight_layout()

    file4 = io.BytesIO()
    plt.savefig(file4)
    file4 = ContentFile(file4.getvalue())

    return file4
Beispiel #3
0
def perform_image_crop(image_obj, crop_rect=None):
    img_ext = os.path.splitext(image_obj.name)[1][1:].upper()
    img_ext = 'JPEG' if img_ext == 'JPG' else img_ext
    if crop_rect is None:
        return image_obj

    image = BytesIO(image_obj.read())

    base_image = Image.open(image)
    tmp_img, tmp_file = base_image.crop(crop_rect), BytesIO()
    tmp_img.save(tmp_file, format=img_ext)

    tmp_file = ContentFile(tmp_file.getvalue())
    return uploadedfile.InMemoryUploadedFile(tmp_file, None, image_obj.name,
                                             image_obj.content_type,
                                             tmp_file.tell, None)
Beispiel #4
0
    def save(self, name, content, save=True):
        new_content = six.StringIO()
        content.file.seek(0)
        thumb = Image.open(content.file)

        width, height = thumb.size
        if width > self.field.max_width or height > self.field.max_height:
            thumb.thumbnail((
                self.field.max_width,
                self.field.max_height
                ), Image.ANTIALIAS)

            if self.field.use_thumbnail_aspect_ratio:
                img = Image.new("RGBA", (self.field.max_width, self.field.max_height), self.field.background_color)
                img.paste(thumb, ((self.field.max_width - thumb.size[0]) / 2, (self.field.max_height - thumb.size[1]) / 2))
            else:
                img = thumb

            img_format = self.field.format if self.field.format else thumb.format
            quality = self.field.quality if self.field.quality else 85
            info = img.info.copy()

            if img_format.upper() == 'JPEG':
                info['quality'] = quality

            if self.field.compression:
                info.update({'compression': self.field.compression})

            if 'optimize' in info or 'progressive' in info:
                #HACK: иначе не сохраняет JPEG
                maxblock = ImageFile.MAXBLOCK
                ImageFile.MAXBLOCK = img.size[0] * img.size[1]

                img.save(new_content, format=img_format, **info)

                ImageFile.MAXBLOCK = maxblock
            else:
                img.save(new_content, format=img_format, **info)

            new_content = ContentFile(new_content.getvalue())
        else:
            new_content = content

        super(ResizedImageFieldFile, self).save(name, new_content, save)
Beispiel #5
0
    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
        threshold = request.GET.get('parameter')
        percentage = float(request.GET.get('percentage'))
        support = float(request.GET.get('support'))
        nodes = int(request.GET.get('nodes'))
        # Read working file data and prepare transactions for
        # Apriori algorithm
        file = WFile.objects.get(pk=kwargs['pk'])
        store_data = pd.read_csv(file.file.path)
        columns = request.GET.getlist('selected')
        dataset = []
        for _, row in store_data.iterrows():
            aux = []
            for c in columns:
                aux.append(c + '=' + row[c])
            dataset.append(aux)

        # A priori algorithm apply: Extraction of frequent itemsets
        # and association rules
        oht = OnehotTransactions()
        oht_ary = oht.fit(dataset).transform(dataset)
        df = pd.DataFrame(oht_ary, columns=oht.columns_)

        frequent_itemsets = apriori(df, min_support=support, use_colnames=True)
        context['frequent_itemsets'] = frequent_itemsets

        rules = association_rules(frequent_itemsets,
                                  metric=threshold,
                                  min_threshold=percentage)
        # rules = association_rules(frequent_itemsets, metric="lift", min_threshold=0.2)
        context['rules'] = rules

        # Building of scatter plot of support vs. confidence
        support = rules.as_matrix(columns=['support'])
        confidence = rules.as_matrix(columns=['confidence'])

        for i in range(len(support)):
            support[i] = support[i] + 0.0025 * (random.randint(1, 10) - 5)
            confidence[i] = confidence[i] + 0.0025 * (random.randint(1, 10) -
                                                      5)

        plt.gcf().clear()
        plt.scatter(support, confidence, alpha=0.5, marker="*")
        plt.xlabel('support')
        plt.ylabel('confidence')
        plt.tight_layout()

        file1 = io.BytesIO()
        plt.savefig(file1)
        file1 = ContentFile(file1.getvalue())

        # Building of histogram
        frequency_array = frequent_itemsets[frequent_itemsets['itemsets'].map(
            len) == 1]
        total_transactions = len(dataset)
        histogram_labels = []
        histogram_frequency = []
        for index, row in frequency_array.iterrows():
            histogram_frequency.append(int(row['support'] *
                                           total_transactions))
            histogram_labels.append(list(row['itemsets'])[0])

        histogram_data = []
        for i in range(len(histogram_labels)):
            histogram_data += [
                histogram_labels[i] for x in range(histogram_frequency[i])
            ]

        #####
        # Create the plot
        #####
        plt.gcf().clear()

        fig, ax = plt.subplots()

        # the histogram of the data
        n, bins, patches = ax.hist(histogram_data)

        # add a 'best fit' line
        ax.set_ylabel('Frequency')
        plt.xticks(histogram_labels, rotation=90, fontsize='x-small')

        # Tweak spacing to prevent clipping of ylabel
        fig.tight_layout()

        file2 = io.BytesIO()
        plt.savefig(file2)
        file2 = ContentFile(file2.getvalue())

        # Building of heat plot
        # Convert the input into a 2D dictionary
        freqMap = {}
        for line in dataset:
            for item in line:
                if not item in freqMap:
                    freqMap[item] = {}

                for other_item in line:
                    if not other_item in freqMap:
                        freqMap[other_item] = {}

                    freqMap[item][other_item] = freqMap[item].get(
                        other_item, 0) + 1
                    freqMap[other_item][item] = freqMap[other_item].get(
                        item, 0) + 1

        df = DataFrame(freqMap).T.fillna(0)

        #####
        # Create the plot
        #####
        plt.gcf().clear()
        plt.pcolormesh(df, edgecolors='black')
        plt.yticks(np.arange(0.5, len(df.index), 1),
                   df.index,
                   fontsize='x-small')
        plt.xticks(np.arange(0.5, len(df.columns), 1),
                   df.columns,
                   rotation=90,
                   fontsize='x-small')
        plt.tight_layout()

        file3 = io.BytesIO()
        plt.savefig(file3)
        file3 = ContentFile(file3.getvalue())

        # Draw graph for association rules
        file4 = draw_graph(rules, nodes)
        print(file1, file2, file3, file4)
        results = AssociationRules.objects.create()
        results.scatter.save('scatter.png', file1)
        results.histogram.save('histogram.png', file2)
        results.heat_map.save('heat_map.png', file3)
        results.graph.save('graph.png', file4)
        context['results'] = results
        return self.render_to_response(context)