final-v

Author: Wenzong Wang

.DS_Store

@@ -0,0 +1,72 @@
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"math"
+	"os"
+	"proj2/png"
+	"runtime"
+	"proj2/src"
+)
+
+func printUsage() {
+	fmt.Printf("Usage: editor [-p=[number of threads]]\n")
+	fmt.Printf("\t-p=[number of threads] = An optional flag to run the editor in its parallel version.\nCall and pass the runtime.GOMAXPROCS(...) function the integer\nspecified by [number of threads].\n")
+}
+
+func sequentialRun(){
+	dec := json.NewDecoder(os.Stdin)
+	var tmp src.Request
+
+	for{
+		// decode an image process request
+		err := dec.Decode(&tmp)
+		if err != nil {
+			return
+		}
+		// load img
+		filePath := tmp.InPath
+		pngImg, err := png.Load(filePath)
+		if err != nil {
+			panic(err)
+		}
+		// apply effects
+		for i := range tmp.Effects{
+			_, height := pngImg.GetSize()
+			pngImg.AddEffect(tmp.Effects[i], 0, height)
+			if i != len(tmp.Effects) - 1{
+				//pngImg.ReLoad()
+				pngImg.Swap()
+			}
+		}
+		//Saves the image to a new file
+		err = pngImg.Save(tmp.OutPath)
+		if err != nil {
+			panic(err)
+		}
+	}
+
+}
+
+func main() {
+	/******
+		The following code shows you how to work with PNG files in Golang. Please
+		write your actual implementation of the project by removing the below code.
+	******/
+	var p int
+	flag.IntVar(&p, "p", 0, "An optional flag to run the editor in its parallel version.\nCall and pass the runtime.GOMAXPROCS(...) function the integer\nspecified by [number of threads].")
+	flag.Parse()
+
+	if p == 0{
+		// sequential version
+		sequentialRun()
+	}else{
+		// parallel version
+		runtime.GOMAXPROCS(p)
+		numOfReaders := int(math.Ceil(float64(p)*(1.0/5.0)))
+		src.CreateReadersWithPPLPool(numOfReaders, p)
+	}
+
+}

editor/.DS_Store

@@ -0,0 +1,3 @@
+module proj2
+
+go 1.14

editor/editor.go

@@ -0,0 +1,89 @@
+// Package png allows for loading png images and applying
+// image flitering effects on them.
+package png
+
+import (
+	"image/color"
+)
+
+var sharp = [9]float64{
+	0, -1, 0,
+	-1, 5, -1,
+	0, -1, 0}
+
+var edge = [9]float64{
+	-1, -1, -1,
+	-1, 8, -1,
+	-1, -1, -1}
+
+var blur = [9]float64{
+	1. / 9, 1. / 9, 1. / 9,
+	1. / 9, 1. / 9, 1. / 9,
+	1. / 9, 1. / 9, 1. / 9}
+
+// apply a certain effect to a rect area [(0,y0), (width, y1)] of the img
+func (img *Image) AddEffect(effect string,  y0 int, y1 int){
+
+	switch effect{
+	case "S":
+		img.FilterRect(sharp, y0, y1)
+	case "E":
+		img.FilterRect(edge, y0, y1)
+	case "B":
+		img.FilterRect(blur, y0, y1)
+	case "G":
+		img.GrayscaleRect(y0, y1)
+	default:
+		img.GrayscaleRect(y0, y1)
+	}
+}
+
+// apply a certain effect to a rect area [(0,y0), (width, y1)] of the img
+func (img *Image) AddEffectRect(effect string, y0 int, y1 int, ch chan bool){
+	img.AddEffect(effect, y0, y1)
+	ch <- true
+}
+
+// apply filter k to a rect area [(0,y0), (width, y1)] of the img
+func (img *Image) FilterRect(k [9]float64, y0 int, y1 int){
+	bounds := img.out.Bounds()
+	for y := y0; y < y1; y++ {
+		for x := bounds.Min.X; x < bounds.Max.X; x++ {
+			var sum_r float64
+			var sum_g float64
+			var sum_b float64
+			var i int
+			_, _, _, a := img.mid.At(x, y).RGBA()
+			for yo := y - 1; yo <= y+1; yo++ {
+				for xo := x - 1; xo <= x+1; xo++ {
+					if img.Contains(xo, yo) {
+						r, g, b, _ := img.mid.At(xo, yo).RGBA()
+						sum_r += k[i] * float64(r)
+						sum_g += k[i] * float64(g)
+						sum_b += k[i] * float64(b)
+					}
+					i++
+				}
+			}
+			img.out.Set(x, y, color.RGBA64{clamp(sum_r), clamp(sum_g), clamp(sum_b), uint16(a)})
+		}
+	}
+}
+
+// apply greyscale effect to a rect area [(0,y0), (width, y1)] of the img
+func (img *Image) GrayscaleRect(y0 int, y1 int) {
+	bounds := img.out.Bounds()
+	for y := y0; y < y1; y++ {
+		for x := bounds.Min.X; x < bounds.Max.X; x++ {
+			r, g, b, a := img.mid.At(x, y).RGBA()
+			greyC := clamp(float64(r+g+b) / 3)
+			img.out.Set(x, y, color.RGBA64{greyC, greyC, greyC, uint16(a)})
+		}
+	}
+}
+
+
+
+
+
+

go.mod

@@ -0,0 +1,115 @@
+// Package png allows for loading png images and applying
+// image flitering effects on them
+package png
+
+import (
+	"image"
+	"image/color"
+	"image/png"
+	"math"
+	"os"
+)
+
+// The Image represents a structure for working with PNG images.
+type Image struct {
+	in  image.Image
+	mid *image.RGBA64
+	out *image.RGBA64
+
+}
+
+//
+// Public functions
+//
+
+// Load returns a Image that was loaded based on the filePath parameter
+func Load(filePath string) (*Image, error) {
+
+	inReader, err := os.Open(filePath)
+
+	if err != nil {
+		return nil, err
+	}
+	defer inReader.Close()
+
+	inImg, err := png.Decode(inReader)
+
+	if err != nil {
+		return nil, err
+	}
+
+	inBounds := inImg.Bounds()
+
+	outImg := image.NewRGBA64(inBounds)
+
+	midImg := image.NewRGBA64(inBounds)
+
+	InitForMid(inImg, midImg)
+
+	return &Image{inImg, midImg, outImg}, nil
+}
+
+func (img *Image)Swap(){
+	img.mid = img.out
+	img.out = image.NewRGBA64(img.in.Bounds())
+}
+
+func InitForMid(inImg image.Image, midImg *image.RGBA64) {
+	inBounds := inImg.Bounds()
+	for y := inBounds.Min.Y; y < inBounds.Max.Y; y++ {
+		for x := inBounds.Min.X; x < inBounds.Max.X; x++ {
+			r, g, b, a := inImg.At(x, y).RGBA()
+			midImg.Set(x, y, color.RGBA64{clamp(float64(r)), clamp(float64(g)), clamp(float64(b)), uint16(a)})
+		}
+	}
+}
+
+func (img *Image) GetSubImage(x0 int, y0 int, x1 int, y1 int) image.Image{
+	rect := image.Rect(x0,y0, x1, y1)
+	return img.mid.SubImage(rect)
+}
+
+// Save saves the image to the given file
+func (img *Image) Save(filePath string) error {
+
+	outWriter, err := os.Create(filePath)
+	if err != nil {
+		return err
+	}
+	defer outWriter.Close()
+
+	err = png.Encode(outWriter, img.out)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (img *Image) Contains(x int, y int) bool {
+
+
+	bounds := img.out.Bounds()
+
+	if x < bounds.Min.X || x  >= bounds.Max.X{
+		return false
+	}
+	if y < bounds.Min.Y || y  >= bounds.Max.Y{
+		return false
+	}
+	return true
+}
+
+func (img *Image) GetSize() (int, int){
+	bounds := img.in.Bounds()
+	width := bounds.Max.X
+	height := bounds.Max.Y
+	return width, height
+}
+
+
+
+//clamp will clamp the comp parameter to zero if it is less than zero or to 65535 if the comp parameter
+// is greater than 65535.
+func clamp(comp float64) uint16 {
+	return uint16(math.Min(65535, math.Max(0, comp)))
+}

png/effects.go

@@ -0,0 +1,68 @@
+package src
+
+import (
+	"encoding/json"
+	"os"
+	"proj2/png"
+	"sync"
+)
+
+// struct for decoding image process request
+type Request struct{
+	InPath string
+	OutPath string
+	Effects []string
+}
+
+// struct for a pre-processed request
+type FilterRequest struct{
+	img *png.Image
+	req Request
+}
+
+// A reader reads from os.stdin and create its own work pipeline for image process
+func readAndProcess(wg *sync.WaitGroup, id int, cond *sync.Cond, dec *json.Decoder, n int){
+	defer wg.Done()
+	done := make(chan bool, 1)
+	filterReq := make(chan FilterRequest, 10)
+
+	var tmp Request
+	for{
+		cond.L.Lock()
+		err := dec.Decode(&tmp)
+		cond.L.Unlock()
+		if err != nil {
+			close(filterReq)
+			return
+		}
+
+		filePath := tmp.InPath
+		pngImg, err := png.Load(filePath)
+		if err != nil {
+			panic(err)
+		}
+
+		var tmpReq FilterRequest
+		tmpReq.img = pngImg
+		tmpReq.req = tmp
+		filterReq <- tmpReq
+		// process the image process with a pipeline
+		go pipelineWork(filterReq, n, done)
+		<-done
+	}
+}
+
+// create a pool of Readers and their work pipeline with a total number of #numOfReaders
+func CreateReadersWithPPLPool(numOfReaders int, numOfThreads int) {
+	var wg sync.WaitGroup
+	var m sync.Mutex
+	cond := sync.NewCond(&m)
+	dec := json.NewDecoder(os.Stdin)
+
+	for i := 0; i < numOfReaders; i++ {
+		wg.Add(1)
+		go readAndProcess(&wg, i, cond, dec, numOfThreads)
+	}
+
+	wg.Wait()
+}